RAD Studio - Modifications récentes [fr]

Pragma alias

Yukikoi — Fri, 09 Oct 2026 19:17:51 GMT

Yukikoi a importé Pragma alias par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{DISPLAYTITLE:#pragma alias}}
{{Parent|Présentation des directives pragma - Index}}

==Syntaxe <span style="font-size: 60%">(voir [[Pseudo-grammaire|Pseudo-grammaire]])</span>==

'''Chaîne d'outils classique''' :

#pragma alias "aliasName" = "substituteName"

'''Chaîne d'outils Clang''' :

la directive <code>#pragma alias</code> n'est pas supportée par les compilateurs [[BCC64X|BCC64X]] et [[Compilateurs Win32 améliorés par Clang|BCC32C]]. A la place, vous pouvez laisser un commentaire pour le lieur en procédant comme suit :

#pragma comment(linker, "/alternatename:<name1><nowiki>=</nowiki><name2>")

==Description==

<code>#pragma alias</code> indique au lieur que deux noms d'identificateurs sont équivalents. Les deux identificateurs doivent être saisis entre guillemets. Sinon, un avertissement [[W8086 Utilisation incorrecte de l'alias pragma "NomAlias"="NomSubstitué" (C++)|W8086 Utilisation incorrecte de l'alias pragma "aliasName"="substituteName" (C++)]] est émis.

Les alias sont à présent gérés dans des unités distinctes, par deux fichiers .obj, un pour Unicode et un pour non-Unicode. Ces deux fichiers .obj font partie de la bibliothèque VCL.

Le <code>NomAlias</code> et le <code>NomSubstitué</code> sont injectés dans leur fichier .obj correspondant, exactement comme ils sont écrits à l'intérieur des guillemets. Le lieur recherche toutes les références à <code>NomAlias</code> et les lie au <code>NomSubstitué</code>.

{{Note| Les [[Fichier d'en-tête C++ (*.h, *.hpp)|fichiers .hpp]] générés depuis le code {{Delphi}} utilisent l'alias <code>#pragma</code> pour la gestion des identificateurs qui sont substantypés différemment dans {{Delphi}} et {{CBuilder}}.}}

[[Category:Référence C++]]
[[Category:C++]]

Fractionnement de l'éditeur

Yukikoi — Fri, 09 Oct 2026 19:17:51 GMT

Yukikoi a importé Fractionnement de l'éditeur par téléversement de fichier (1 version) LOC-23451

Nouvelle page

La vue [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] permet d’utiliser plusieurs éditeurs côte à côte, les uns au-dessus des autres, ou de façon combinée, le tout dans une même fenêtre. Cela inclut la possibilité de faire glisser des ensembles d'onglets vers des fenêtres flottantes, puis de les replacer dans l'EDI.
Elle permet aussi d'avoir plusieurs dispositions personnalisées et offre diverses possibilités de manipulation : disposition simple en deux colonnes, disposition sur plusieurs lignes, ou une configuration particulièrement adaptée à votre flux de travail.
Vous pouvez travailler en ayant plusieurs onglets ouverts, et ouvrir la même unité dans chacun de ces onglets. Vous pouvez aussi avoir plusieurs onglets ouverts : l'un avec le concepteur de fiche et plusieurs autres avec le code de l'unité correspondante. L'onglet contenant le concepteur de fiche peut aussi être déplacé.
Il n'y a '''aucune limite''' quant au nombre de vues fractionnées, que ce soit horizontalement ou verticalement.

===Utilisation du fractionnement de l'éditeur===

Vous pouvez accéder à la vue Fractionnement de l'éditeur en cliquant avec le bouton droit sur un onglet et en choisissant '''Fractionner >''' ou '''Déplacer >'''. Le fractionnement crée une nouvelle version de l'onglet sélectionné, et le déplacement provoque son ouverture à l'endroit sélectionné dans l'EDI.

[[File:Using-spliteditor.png|=link|400px|border]]

Les raccourcis suivants peuvent être utilisés pour les deux options :

*'''Fractionner en haut :''' Alt+Maj+T
*'''Fractionner en bas :''' Alt+Maj+B
*'''Fractionner à droite :''' Alt+Maj+R
*'''Fractionner à gauche :''' Alt+Maj+L
*'''Déplacer en haut :''' Ctrl+Alt+Maj+T
*'''Déplacer à gauche :''' Ctrl+Alt+Maj+L
*'''Déplacer à droite :''' Ctrl+Alt+Maj+R
*'''Déplacer en bas :''' Ctrl+Alt+Maj+B

Alternativement, vous pouvez utiliser [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] en faisant glisser un fichier de la vue Projets dans un onglet de l'éditeur. Vous pouvez aussi effectuer un clic droit sur le fichier du projet, puis sélectionner l'option '''Ouvrir dans''' et choisir l'onglet de l'éditeur dans lequel vous souhaitez ouvrir le fichier.

Lorsque deux onglets sont dans une fenêtre, chacun a une barre de titre.

Le fractionnement de l'éditeur vous permet de :

*Faire glisser un onglet de l'éditeur, ou un ensemble d'onglets, en faisant glisser la barre de titre et en l'ancrant sur n'importe quel côté de la fenêtre de l'EDI.
*Le faire glisser et l'ancrer sur n'importe côté de l'éditeur (gauche, droit, haut, bas).
*Le fusionner avec un ensemble d'onglets en le faisant glisser au centre d'un éditeur existant, y compris une fenêtre flottante d'onglets.
*Le faire glisser en dehors de sa propre fenêtre (soit un seul onglet ou un ensemble d'onglets).

La plupart des opérations peuvent être réalisées sur des onglets individuels. Il peut s'agir par exemple de déplacer un onglet entre des ensembles d'onglets ancrés en faisant glisser l'onglet individuel d'un emplacement à un autre.

Chaque ensemble d'onglets peut être déplacé à l'extérieur de sa propre fenêtre. Faites glisser la barre de titre pour le déplacer.
{{Tip| Vous pouvez appuyer sur Ctrl tout en faisant glisser l'ensemble d'onglets pour vous assurer qu'il ne s'ancre pas.}}

De la même façon, chaque fenêtre peut être ancrée à côté d'un autre ensemble d'onglets. Pour cela, vous devez faire glisser la barre de titre.

{{Note|La plupart des éditeurs/groupes disparaissent de la vue lorsqu'ils sont fermés. Toutefois, la fermeture du premier éditeur (celui qui était auparavant l'éditeur de la fenêtre principale) avec le bouton ‘X’ provoque la fermeture de tous les onglets qu'il contient. L'espace qu'il occupait reste ouvert, car l'éditeur original ne peut pas être fermé. Cela n'a aucune incidence tant que les groupes d'onglets ne sont pas fermés. Il n'y a aucun impact visible lorsque vous créez, déplacez ou ancrez les onglets dans vos tâches.}}

[[File:Split Editor Example.png|800px|]]

''C'est l'une des nombreuses façons de configurer la vue Fractionnement de l'éditeur. Elle comporte une fenêtre d'édition sur la gauche, deux à droite, et les volets sont masqués mais apparaissent lorsqu'ils sont survolés par la souris.''

===Concepteur et code===

Les vues Fractionnement de l'éditeur permettent de modifier un même fichier dans deux fenêtres d'édition affichées côte à côte, chacune affichant le même contenu de fichier. Lorsque vous tapez dans l'une et que vous faites défiler le texte jusqu'à un emplacement, le texte apparaît dans l'autre fenêtre. Vous pouvez faire défiler les deux fenêtres indépendamment l'une de l'autre, ce qui permet de modifier le fichier à plusieurs endroits.
Vous pouvez ainsi ouvrir un même fichier dans autant d'onglets que vous le souhaitez.
{{Note|Gardez toujours à l'esprit qu'il n'y a qu'un seul fichier (module ou tampon de fichier en termes internes) affiché dans plusieurs vues. Ainsi, toute modification effectuée dans l'une de ces vues sera répercutée dans les autres vues (il ne s'agit pas de copier ou de dupliquer une modification).

Autrement dit, toute modification de fichier depuis une fenêtre d'édition concerne le fichier lui-même et pas la fenêtre. Cette modification sera répercutée dans les autres vues. }}

===Conseils et astuces===

*'''Enregistrez''' la configuration des éditeurs en tant que disposition du bureau. Sinon, vous risquez de passer beaucoup de temps à définir une présentation qui ne sera pas sauvegardée.

{{Notes|

*Lorsque la disposition de bureau est modifiée, la configuration change également (par ex. lorsque l'EDI commence le débogage et passe en '''Disposition de débogage'''.
*Lorsque vous changez de disposition, tout groupe d'onglets qui ne trouve pas sa place dans la disposition est détaché et devient une fenêtre flottante.}}
*Activez '''Options''' > '''Enregistrement et récupération''' > '''Enregistrer le bureau du projet lors de la fermeture''' et '''Enregistrer l'état de l'éditeur à la fermeture d'un onglet'''.
*Lorsque vous enregistrez l'état de l'éditeur, vous enregistrez également la position de défilement, les zones réduites ou développées, etc. C'est très pratique lorsque plusieurs fenêtres d'édition du même fichier sont ouvertes. Ainsi, lorsque vous rouvrez votre bureau et rouvrez le projet (ou tout simplement, lorsque vous rouvrez un éditeur précédemment fermé), la nouvelle fenêtre d'édition s'affiche telle qu'elle était au moment de la fermeture.
*Pensez à désancrer les volets ancrables d'ancienne génération. Ils sont réduits sous forme de petit onglet sur un côté de la fenêtre principale. Vous pouvez les rendre visibles à nouveau en cliquant dessus, et ils restent affichés tant qu’ils ont la focalisation. Pour cela, vous devez cliquer sur le bouton d'épinglage dans la barre de titre du volet, à côté du bouton X. Cette fonctionnalité existe depuis de nombreuses années, mais elle n’était vraiment utile que lorsque l’espace à l'écran était limité. Maintenant que plusieurs fenêtres d'édition peuvent être fractionnées et ancrées ensemble, il devient très pratique de pouvoir désépingler les volets latéraux pour libérer de l’espace horizontal.
*Pensez à faire un clic droit sur un onglet '''> Fractionner > A droite''' (ou '''A gauche'''). L'utilisation de plusieurs colonnes est certainement la configuration la plus courante pour les vues fractionnées. Plus vous utiliserez cette fonctionnalité, plus vous constaterez son utilité.

==Voir aussi==

*[[Présentation de l'EDI|Présentation de l'EDI]]
*[[Aperçu et page d'accueil|Aperçu et page d'accueil]]

WebStencils

Yukikoi — Fri, 09 Oct 2026 19:17:51 GMT

Yukikoi a importé WebStencils par téléversement de fichier (1 version) LOC-23451

Nouvelle page

WebStencils, un système d'intégration et de traitement des fichiers HTML côté serveur, a été introduit dans {{Product}} version 12.2 pour les technologies WebBroker et RAD Server. Cette fonctionnalité flexible permet aux développeurs de concevoir des sites web modernes basés sur n'importe quelle bibliothèque JavaScript tout en exploitant les données extraites et traitées par une application serveur RAD Studio. Cette technologie offre une grande flexibilité pour créer des sites web adaptés à vos besoins spécifiques.

WebStencils a pour objectif de faciliter la création de sites de navigation par l'adoption des technologies Web (WebBroker, DataSnap, RAD Server) en fournissant des scripts côté serveur. Il est ainsi possible de générer des pages HTML avec des outils standard et d'utiliser n'importe quelle bibliothèque CSS et JavaScript tout en ajoutant des données à partir des pages générées depuis l'application (il peut s'agir par exemple du résultat d'une requête de base de données).

De plus, WebStencils constitue une excellente base pour le développement Web avec HTMX. Les pages HTMX bénéficient de la génération de code côté serveur et peuvent se connecter à des serveurs REST pour la mise à jour du contenu. Les technologies Web de Delphi offrent des fonctionnalités de génération de page et d'API REST de très haut niveau.

==Syntaxe de WebStencil==

Le langage de script de WebStencils repose sur deux éléments et est relativement simple :

* Le {{code|'''@''' }}
* Les accolades {{code| '''{ }''' }}

===Utilisation du symbole {{code|@}}===

WebStencils utilise le symbole {{code|'''@'''}} comme marqueur spécial plutôt que des balises HTML/XML ou d'autres notations. Le symbole {{code|'''@'''}} est suivi par :

* Le nom d'un objet ou d'un champ.
* Un [[WebStencils#Mots clé de WebStencils|mot clé spécial]].
* Un autre symbole {{code|'''@'''}}. {{Tip| L'utilisation du symbole {{code|'''@'''}} est plus souple. Ainsi, vous n'aurez pas besoin de le doubler dans certaines situations, comme dans les en-têtes.}}

L'accès général à une valeur est basé sur une notation par point, sous la forme object.value. C'est pourquoi vous observerez des balises comme :

@object.value

Le nom de '''l'objet''' est un nom symbolique local qui peut correspondre à un objet réel d'une application serveur, assigné à l'exécution du script via un processus de recensement. Il peut aussi être résolu dans le code lors du traitement d'un gestionnaire d'événement OnGetValue.

La valeur est composée du nom de la propriété (pour un objet générique), du nom d'un champ (si l'objet hérite de TDataSet), et d'une chaîne qui est transmise dans le gestionnaire d'événement OnGetValue associé au processeur.

{{Note|La sortie des valeurs traitées par WebStencils est chiffrée avec la méthode TNetEncoding.HTML.Encode. Vous pouvez supprimer le chiffrement en utilisant la syntaxe {{code|@\value}}.}}

====Accès aux ensembles de données et objets imbriqués====

Vous pouvez aussi utiliser le symbole {{code|'''@'''}} pour accéder à des ensembles de données et des objets imbriqués en utilisant la syntaxe suggérée dans les scénarios suivants :

* Objets et classes imbriqués :<source lang="delphi">
@MyObject.SubObject.ProperyName</source>
* Tables dans les ensembles de données imbriqués :<source lang="delphi">
@MyDataSet.DataSetField.SubField</source>

===Utilisation des accolades pour les blocs {{code|{}}}===

La seconde notation utilise des accolades, {{code|{}} et {{code|}}}, pour indiquer les blocs conditionnels ou répétés.

Toute autre utilisation des accolades dans le fichier de code source (le fichier HTML) est ignorée. En d'autres termes, les accolades ne sont traitées que si elles sont utilisées après une instruction conditionnelle WebStencils spécifique.

===Accès à des valeurs avec la notation par point===

Prenons en exemple l'extrait de code HTML WebStencils ci-dessous :<source lang="delphi">
<h2>GetValue</h2>
<p>Value obtained from data: @data.name</p>
<p>Value obtained with request @@data.value: @data.value</p></source>

Les symboles {{code|@@}} sont ignorés (nous attendons un seul {{code|@}} en sortie). Il suffit d'un seul pour déclencher le traitement.
Notez également que les deux symboles, le nom d'objet et le nom de valeur, doivent être des identificateurs Delphi valides et ne peuvent pas contenir d'espaces ni commencer par un chiffre. Un nom peut contenir des caractères de soulignement et des chiffres.

===Gestionnaire d'événement OnValue===

Il est possible de fournir des données en utilisant un composant avec le gestionnaire d'événement OnValue. Par exemple :
'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebStencilsValueFromEventValue(Sender: TObject;
const ObjectName, FieldName: string; var ReplaceText: string;
var Handled: Boolean)
begin
if SameText (ObjectName, 'data') then
begin
Handled := True;
ReplaceText := 'You requested ' + FieldName;
end;
end;</source>

Dans le code exemple ci-dessus, le code vérifie uniquement le nom d'objet (la première partie du symbole avant le point), mais il est recommandé de vérifier également la propriété FieldName (le symbole après le point).

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebStencilsValueFromEventValue(TObject *Sender,
const String ObjectName, const String FieldName, String &ReplaceText, bool &Handled)
{
if (SameText(ObjectName, "data"))
{
Handled = true;
ReplaceText = "You requested " + FieldName;
}
}</source>

Dans l'exemple ci-dessus, {{code|String}} est une chaîne {{code|UnicodeString}} compatible Delphi dans C++ Builder. {{code|SameText}} est une fonction de comparaison de chaînes insensible à la casse fournie par SysUtils. Enfin, {{code|&ReplaceText}} et {{code|&Handled}} sont transmis par référence pour permettre la modification et reproduire le comportement {{code|var}} de Delphi.

===Utilisation d'un objet dans le dictionnaire de variables de script===

Une autre approche consiste à fournir les valeurs en utilisant un objet. Dans ce cas, l'objet doit être configuré et associé à l'action du producteur.

Voici un exemple complet, supposant une classe TMyObject et sa propriété Name :
'''Delphi :'''<source lang="delphi">
procedure TWebModule1.WebModule1WebActionItem2Action(Sender: TObject;
Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
begin
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetValue</h2>
<p>Value obtained from data: @world.Name</p>
''';
var MyObj := TMyObject.Create();
MyObj.Name := 'Hello hello';
WebStencilsProcessor1.AddVar('world', MyObj, True);
Response.Content := WebStencilsProcessor1.Content;
Handled := True;
end;</source>

Cet exemple donne le résultat suivant :

"Value obtained from data: Hello Hello"

Notez que l'objet est recensé avec le nom 'world', qui sera ensuite utilisé dans le script WebStencils.

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule1::WebModule1WebActionItem2Action(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
WebStencilsProcessor1->InputLines->Text =
"<h2>GetValue</h2>\n"
"<p>Value obtained from data: @world.Name</p>";

TMyObject *MyObj = new TMyObject();
MyObj->Name = "Hello hello";

WebStencilsProcessor1->AddVar("world", MyObj, true);

Response->Content = WebStencilsProcessor1->Content;
Handled = true;
}</source>

===Expressions===

Voici la liste des expressions prises en charge :

*{{code|'''@ (<expression>)'''}} - marqueurs de variable. L'expression doit être écrite entre parenthèses.
*{{code|'''@if (<expression>)'''}} - commande "if". L'expression doit être écrite entre parenthèses.
*{{code|'''@Import (<expression>)'''}}, {{code|'''@LayoutPage (<expression>)'''}}, {{code|'''@AddPage (<expression>)'''}} - ''commandes de fichier. L'expression doit être écrite entre accolades.''

L'exemple suivant montre uniquement les différences entre les options ci-dessus :<source lang="delphi">
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetExpression</h2>
<p>Value obtained from data: @(world.value*2)</p>
''';
MyObj.Value := 2;</source>

Vous obtenez alors la sortie suivante :

"Value obtained from data: 4"

En plus des expressions simples, vous pouvez étendre le système en utilisant des appels de fonction personnalisés. Voici un exemple de code qui recense une fonction “'''Concat'''” recevant deux paramètres chaîne :
'''Delphi :'''<source lang="delphi">
uses
System.Bindings.EvalProtocol, System.Bindings.Methods;

TBindingMethodsFactory.RegisterMethod(
TMethodDescription.Create(
MakeInvokable(function(Args: TArray<IValue>): IValue
begin
Result := TValueWrapper.Create(
Args[0].GetValue.AsString + Args[1].GetValue.AsString);
end),
'Concat', 'Concat', '', True, '', nil));</source>

Dans un script WebStencils, vous pouvez l'utiliser dans une expression comme :

@(Concat('aaa', 'bbb']]

'''C++ :'''<source lang="cpp">
#include <System.Bindings.EvalProtocol.hpp>
#include <System.Bindings.Methods.hpp>
#include <System.Rtti.hpp>
#include <System.SysUtils.hpp>

using namespace System::Bindings::EvalProtocol;
using namespace System::Bindings::Methods;
using namespace System::Rtti;

class TValueWrapper : public TInterfacedObject, public IValue
{
private:
TValue FValue;

public:
__fastcall TValueWrapper(const TValue &AValue) : FValue(AValue) {}

virtual TValue __fastcall GetValue() { return FValue; }

// Implement other IValue methods as needed...
};

void RegisterCustomBindingMethod()
{
TBindingMethodsFactory::RegisterMethod(
new TMethodDescription(
MakeInvokable([](const TArray<IValue*> &Args) -> IValue*
{
String s1 = Args[0]->GetValue().ToString();
String s2 = Args[1]->GetValue().ToString();
return new TValueWrapper(TValue::From<String>(s1 + s2));
}),
"Concat", "Concat", "", true, "", nullptr));
}</source>

====Instruction Switch====

En plus de l'instruction {{code|@if}}, les utilisateurs peuvent choisir d'utiliser les instructions {{code|@switch}} ou {{code|@case}}.

Voici un exemple de syntaxe :<source>
@switch(@user.role) {
@case "admin" {
<div>Admin Panel</div>
} @case "moderator" {
<div>Moderator Tools</div>
} @default {
<div>Regular User View</div>
}
}</source>

A partir de l'exemple ci-dessus, notez que :

*Les valeurs des "case" peuvent être des littéraux ou des expressions utilisant {{code|@}}(expression).
*Seul le premier "case" correspondant est exécuté.
*L'utilisation de {{code|@default}} est facultative et s'exécute s'il n'y a pas de correspondance avec "case"'.

===Utilisation d'un ensemble de données===

Une alternative consiste à utiliser l'enregistrement en cours d'un ensemble de données plutôt qu'un objet. Dans ce cas, votre code sera comme suit :
'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebModule13waCompanyAction(Sender: TObject;
Request: TWebRequest; Response: TWebResponse;
var Handled: Boolean];
begin
ClientDataSet1.Open;
if not WebStencilsValueFromObject.InVars ('dataset'] then
WebStencilsValueFromObject.AddVar(
'dataset', ClientDataSet1, False]; // False = do not destroy
Response.Content := WebStencilsValueFromObject.Content;
ClientDataSet1.Close;
end;</source>

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebModule13waCompanyAction(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
ClientDataSet1->Open();

if (!WebStencilsValueFromObject->InVars("dataset"))
{
WebStencilsValueFromObject->AddVar("dataset", ClientDataSet1, false); // false = do not destroy
}

Response->Content = WebStencilsValueFromObject->Content;

ClientDataSet1->Close();
}</source>

Le code HTML correspondant peut contenir des références à certains champs de l'enregistrement. Voici un exemple de résultat :<source lang="delphi">
<div class="list-group w-50">
@foreach dataset {
<a href="/company?id=@loop.custno" class="list-group-item
list-group-item-action" aria-current="true">
<div class="d-flex w-100 justify-content-between">
<h5 class="mb-1">@loop.company</h5>
<small>@loop.country</small>
</div>
<p class="mb-1">@loop.city</p>
<small>@loop.state</small>
</a>
}</source>

====Accès aux propriétés de l'ensemble de données====

La notation WebStencils {{code|@}} relative à un ensemble de données permet d'accéder aux propriétés de l'ensemble de données, en plus de ses champs. Les utilisateurs peuvent utiliser {{code|@data.RecordCount}} pour accéder à la propriété RecordCount. En cas de conflit, les champs de l'ensemble de données ont priorité sur les propriétés portant le même nom.

Cela inclut l'accès aux informations des champs, comme suit :

@foreach field in customers.fields

Ainsi que l'accès aux propriétés des champs :<source>
@foreach customer in customers {
@customer.address.visible
@customer.phone.displaylabel
}</source>

==Utilisation de variables de modules==

Alternativement, pour recenser un objet spécifique pour un WebStencilsProcessor, vous pouvez ajouter un “'''module'''” avec plusieurs objets. Dans ce contexte, un 'module' est une collection d'objets ou de fonctions liés entre eux. N'importe quel champ ou n'importe quelle propriété du module peut être décoré avec l'attribut {{code|'''[WebStencilsVar]'''}}, qui vous permet de spécifier comment le WebStencilsProcessor doit traiter les données.

Par exemple, supposons que votre module de données a un composant FDMemTable1 de type TFDMemTable marqué comme {{code|'''[WebStencilsVar]'''}}, et un champ LastName, vous pouvez écrire :

<source lang="delphi">

WebStencilsProcessor1.InputLines.Text := '''
<h2>GetTableData</h2>
<p>Value obtained from table: @(FDMemTable1.LastName)</p>
''';
WebStencilsProcessor1.AddModule(self);</source>L'exemple ci-dessous renvoie la valeur de LastName dans le premier enregistrement. Utilisez une boucle {{code|'''@for'''}} pour afficher tous les enregistrements.

===Utilisation de variables supplémentaires===

Ajoutez des variables supplémentaires au moteur de script à l'extérieur des modèles d'objet et d'ensemble de données. Plutôt que d'ajouter une structure de données spécifique, ce mécanisme propose une méthode anonyme qui permet d'implémenter une recherche personnalisée dans une structure de données personnalisée. Il s'agit des méthodes suivantes :

TWebStencilsDataVars.Add(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsProcessor.AddVar(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsEngine.AddVar(LookupFunc), AddInitFunc(LookupFunc)

Voici un exemple :

<source lang="delphi">
type
TMap = TDictionary<string, string>;
var
LDict: TMap;
begin
LDict := TMap.Create;
LDict.Add('APP_VERSION', '1.0.0');
LDict.Add('APP_NAME', 'WebStencils demo');
LDict.Add('COMPANY_NAME', 'Embarcadero Inc.');
LDict.Add('DEBUG_MODE', 'True');

FWebStencilsProcessor.AddVar('env', LDict, True,
function(AVar: TWebStencilsDataVar; const APropName: string;
var AValue: string): Boolean
begin
Result := TMap(AVar.TheObject).TryGetValue(APropName.ToUpper, AValue);
end);</source>

Vous pouvez aussi l'utiliser dans un modèle, comme suit :

<source>
@env.APP_NAME - @env.APP_VERSION
@if env.DEBUG_MODE {
<div>Debug mode active</div>
}</source>

==Mots clés de WebStencil==

Le moteur WebStencils utilise les balises suivantes sous forme de mots clés (notez que ces noms ne peuvent pas être utilisés pour des variables de script).

{| class="wikitable"
|-
!Mot clé
!Description
|-
|{{code| '''@query'''}}
|Utilisé pour lire des paramètres de requête HTTP.
|-
|{{code| '''@page'''}}
|Fournit l'accès au nom de la page et aux arguments de l'URL (voir la propriété [[WebStencils#Utilisation de WebStencils avec RAD Server|PathTemplate]] pour plus d'informations). Il est possible d'accéder au chemin de l'URL en utilisant l'une de ces valeurs :
*{{code|@page.request_path}}
*{{code|@page.request_segment}}
|-
|{{code| '''@lang'''}}
|Utilisé pour la prise en charge de la traduction, déclenche un événement OnLang distinct plutôt que l'événement OnValue.
|-
|{{code| '''@* .. *@'''}}
|Utilisé pour ajouter des commentaires dans le script, qui seront omis dans le HTML résultant.
|-
|{{code| '''@if'''}} object.value { … } ['''@else''' { … }]
|Exécute le bloc suivant entre accolades uniquement si la valeur vaut {{code|true}}.
|-
|{{code| '''@if (<expression>)'''}}
|Utilisé pour restituer du contenu de façon conditionnelle. Si l'expression est évaluée à {{code|true}}, le contenu associé est inclus dans la sortie ; sinon il est omis.
|-
|{{code| '''@if not''' object.value { ... } ['''@else''' { … }]}}
|Exécute le bloc suivant entre accolades uniquement si la valeur ne vaut pas {{code|true}}. <br />Par exemple :
<source lang="delphi">
@if obj1.ValueBelowTen {
<p>@obj1.name <span> has a value of </span> @obj1.value</p>
}</source>
|-
|{{code| '''@ForEach''' (var object in list) { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement :
*Les ensembles de données
*TObjectList, doit être ajouté au dictionnaire de processeur.
*Tout objet possédant la méthode GetEnumerator, où l'énumérateur renvoie une valeur d'objet.
|-
|{{code| '''@ForEach''' object { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement les ensembles de données et TObjectList, qui doivent être ajoutés en tant que variables de script.
|-
|{{code|'''@loop'''}}
|Utilisez à l'intérieur d'un bloc pour faire référence à l'élément en cours de l'énumération (liste ou ensemble de données). Il doit être suivi du nom d'une propriété ou d'un champ sans utiliser de nom d'objet.
|-
|{{code|'''@Import'''}}
|Permet de fusionner un fichier externe à un emplacement spécifique du fichier externe. Suppose toutefois que le nom de fichier ait l'extension .HTML. <br />Le format doit être comme suit :
<source lang="delphi">
@import filename [ {<alias1> = <var1> [..., <aliasN> = <varN>]} ]</source>
|-
|{{code|'''@Scaffolding'''}}
|Espace réservé pour le scaffolding. Ce mécanisme permet de générer dynamiquement du code HTML à partir de la structure de données d'une application (les propriétés d'un objet et les champs d'une base de données). Le code HTML généré côté serveur peut inclure d'autres balises pour accéder aux données. <br />Le code suivant est un exemple de disposition HTML simple générée dans le gestionnaire d'événement OnScaffolding pour chacun des champs de la base de données.
<source lang="delphi">
procedure TWebModule1.ProcessorCompanyScaffolding(Sender: TObject;
const AQualifClassName: string; var AReplaceText: string);
begin
if SameText (AQualifClassName, 'Company') then
begin
AReplaceText := '';
for var I := 0 to ClientDataSet1.Fields.Count -1 do
AReplaceText := AReplaceText + '<p>'+
ClientDataSet1.Fields[I].FieldName +
': @dataset.' + ClientDataSet1.Fields[I].FieldName + '</p>';
end;
end;</source>
|-
|{{code|'''@switch'''}}, {{code|'''@case'''}}, {{code|'''@default'''}}
|Effectue un rendu conditionnel à branches multiples. Après avoir évalué une expression, la met en correspondance avec les valeurs définies avec @case, en restituant le bloc correspondant. La directive @default est utilisée si aucune correspondance n'est trouvée pour @case.
|-
|{{code|'''@LoginRequired'''}}
|Arrête l'exécution si une connexion est requise alors que l'utilisateur n'est pas connecté.
|-
|{{code|'''@LoginRequired (<role>)'''}}
|Le moteur vérifie que l'utilisateur est connecté, mais aussi qu'il dispose du rôle spécifique actif, ce qui restreint l'accès à la page selon la permission.<br /> Par exemple : '''@LoginRequired (admin)'''
|}

===Alias d'importation===

L'exemple ci-dessous illustre comment utiliser des alias d'importation.<source lang="delphi">
@import one {@o1 = @object, @d1 = @data} Hello</source>

Dans ce code, '''@object''' et '''@data''' sont les véritables variables dans le script exécuté. Les alias '''@o1''' et '''@d1''' sont des variables de script pour le script "one" et sont accessibles dans ce script comme des variables normales. Ainsi, vous pouvez transmettre au script QA des variables portant des noms différents, en fournissant comme alias le nom attendu par le script.

==Modèles WebStencils : disposition et corps==

La capacité à fusionner un modèle HTML partagé avec le contenu d'une page compte parmi les fonctionnalités indispensables d'un moteur de modèle. Cette opération s'effectue (comme dans la version .NET) en utilisant quatre symboles spéciaux :

* '''@LayoutPage filename''' : cette commande est utilisée dans une page HTML spécifique (généralement en haut de page) pour indiquer le fichier de modèle à utiliser comme structure de la page. Plusieurs pages peuvent partager un même modèle, mais toutes les pages d'un projet (même en utilisant TWebStencilsEngine) ou d'un dossier virtuel n'ont pas nécessairement besoin d'utiliser le même modèle.

:{{Note| Cette commande ne doit être utilisée qu'une seule fois par page. Si vous tentez d'utiliser plusieurs fois '''@LayoutPage''', une exception se déclenche et bloque la commande.}}

* '''@RenderBody''' : cette commande sans paramètre est une marque de réservation dans un fichier de modèle qui indique où placer le contenu d'une page spécifique.

Voici un exemple d'utilisation de '''@LayoutPage''' et de '''@RenderBody''' :

'''Test.html'''<source lang="delphi">
@LayoutPage BaseTemplate
<h2>Page Test3</h2>
<p>Local data param one is @page.name (the page name)</p></source>

'''BaseTemplate.html'''<source lang="delphi">
<html lang="en">
<head>

@extends layouts/intermediate
@ExtraHeader {
<style>.highlight { color: green; }</style>
}


@extends layouts/base
@ExtraHeader {
<meta name="viewport" content="width=device-width, initial-scale=1">
}


<head>
@RenderHeader
</head></source>

Dans l'exemple ci-dessus, le CSS de {{code|page.html}} et la balise meta de {{code|intermediate.html}} sont injectés dans la sortie finale de {{code|@RenderHeader}}.

==Composants de WebStencils==

Le package WebStencils installe deux composants différents : un processeur de fichier unique et un moteur qui instancie des processeurs individuels et fournit une configuration globale pour les processeurs autonomes ou ceux auxquels ils sont manuellement connectés.

Le composant principal prend un fichier HTML, incorpore la notation WebStencils et le convertit en HTML brut après avoir traité les balises {{code|'''@'''}}.

La classe '''TWebStencilsProcessor''' traite un fichier individuel (généralement ayant une extension HTML) et son modèle associé, le cas échéant. Le processeur peut être utilisé de façon autonome et assigné au '''TWebActionItem.Producer''', ou être créé et appelé par TWebStencilsEngine en tant que post-processeur de fichiers texte renvoyés par un répartiteur de fichiers.

===Composant WebStencilsEngine===

Le composant '''Engine''' peut être utilisé dans les deux scénarios suivants :

*Pour le connecter à un ou plusieurs composants '''WebStencilsProcessor''' et fournir des comportements et des paramètres partagés.
*Pour créer des composants '''WebStencilsProcessor''' lorsque cela est nécessaire, et placer uniquement ce composant sur vos modules web.

==Intégration automatique de sessions==

Lorsqu'elles sont disponibles, [[WebStencils|WebStencils]] peut automatiquement s'intégrer à des sessions web. Aucune configuration supplémentaire n'est nécessaire. Tout se fait automatiquement dès lors que {{code|WebRequest.Sessions}} existe.

Les données des sessions sont accessibles via {{code|@session.property}}. Tous les objets dans {{code|WebRequest.Session.DataVars}} sont automatiquement recensés en tant que variables de modèles. De même, {{code|UserLoggedIn}} et {{code|UserRoles}} sont automatiquement remplis à partir de {{code|WebRequest.Session.User}}.

En voici un exemple :<source>
@if session.Authenticated {
<div>User authenticated</div>
@session.sessionid
}

@if session.UserHasRole(‘admin’) {
<div>User is an Admin</div>
}</source>

==Liste blanche de sécurité==

Pour des raisons de sécurité, WebStencils implémente un mécanisme de liste blanche de propriétés pour éviter l'exposition d'informations sensibles comme les chaînes de connexion aux bases de données. Par défaut, seules les propriétés sécurisées sont accessibles. Voici la liste des propriétés sécurisées :

*Pour les '''TDataSet''' : Active, FieldByName, First, Last, Next, Prior, Bof, Eof, FieldCount, Fields, Found, RecordCount, RecNo.
*Pour les '''TStrings''' : Contains, ContainsName, IndexOf, IndexOfName, CommaText, Count, IsEmpty, DelimitedText, Names, KeyNames, Values, ValueFromIndex, Strings, Text.

===Personnalisation de la liste blanche===

La liste blanche peut être personnalisée en utilisant la propriété [[lib_fr:Web.Stencils.TWebStencilsProcessor.Whitelist|TWebStencilsProcessor.Whitelist]]. La méthode de configuration permet aux utilisateurs de spécifier les membres autorisés et ceux bloqués. Voir l'exemple ci-dessous :<source>
procedure Configure(const AClass: <PTypeInfo, TClass, TObject>;
const AAllowedMembers: TArray<string>;
const ABlockedMembers: TArray<string>;
AReset: Boolean);</source>

* '''AClass''' : le type PTypeInfo/TClass/TObject pour configurer des éléments tels que des TDataSet, TStrings.
* '''AAllowedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite autoriser.
* '''ABlockedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite bloquer.
* '''AReset''' : {{code|True}} lorsqu'utilisé pour remplacer une liste blanche existante, ou {{code|False}} pour ajouter des éléments à la liste.

Voici un exemple qui illustre comment ajouter des membres autorisés supplémentaires à une liste blanche existante :<source>
TWebStencilsProcessor.Whitelist.Configure(TMyClass,
['CustomProp'], nil, False);</source>

Voici un exemple qui illustre comment remplacer la totalité d'une liste blanche (AReset = True) :<source>
TWebStencilsProcessor.Whitelist.Configure(TDataSet,
['RecordCount', 'RecNo'], nil, True);</source>

Voici un exemple qui illustre comment bloquer certains membres :<source>
TWebStencilsProcessor.Whitelist.Configure(MyObject,
nil, ['CustomProp'], False);</source>

La liste blanche s'applique à l'ensemble de l'application et à tous les WebStencils.

==Utilisation de WebStencils avec RAD Server==

La bibliothèque de modèles WebStencils peut aussi être utilisée dans une application RAD Server. Il est recommandé de combiner le composant ''TEMSFileResource''' existant avec un composant '''TWebStencilsEngine'''. Le premier permet de mapper le système de fichiers, alors que le second gère le mappage HTTP et le traitement des modèles. Les composants sont connectés en utilisant la propriété Dispatcher du moteur WebStencil.

L'exemple ci-dessous illustre la configuration nécessaire pour ajouter deux composants à un module web RAD Server :<source lang="delphi">
object html: TEMSFileResource
PathTemplate = '..\..\html\{filename}'
end
object WebStencilsEngine1: TWebStencilsEngine
Dispatcher = html
PathTemplates = <
item
Template = '/'
Redirect = '/test1.html'
end
item
Template = '/list'
Redirect = '/companylist.html'
end
item
Template = '/company'
OnPathInit = WebStencilsEngine1PathTemplates2PathInit
end
...>
end</source>

Les PathTemplates sont utilisés pour mapper les URL entrantes à des fichiers. En mode conception, la configuration se présente comme suit :

[[File:PathTemplates WebStencils.png|350px|=link]]

De plus, il est nécessaire de configurer le mappage de plus haut niveau dans le module de données :

<source lang="delphi">
type
[ResourceName('testfile')]
TTestfileResource1 = class(TDataModule)
[ResourceSuffix('./')]
[ResourceSuffix('get', './')]
[EndpointProduce('get', 'text/html')]
html: TEMSFileResource;</source>

Pour mapper plusieurs chemins différents (à la différence de l'exemple ci-dessus), ajoutez des composants '''TEMSFileResource'''. Le composant '''TWebStencilsEngine''' peut comporter un seul dispatcher dans la propriété correspondante. Pour associer davantage de dispatchers, utilisez le code suivant :

<source lang="delphi">
AddProcessor(html2, WebStencilsEngine1);</source>

==Voir aussi==

*[[Présentation de RAD Server|Présentation de RAD Server]]

Pragma alias

Yukikoi — Fri, 09 Oct 2026 18:47:07 GMT

Yukikoi a importé Pragma alias par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{DISPLAYTITLE:#pragma alias}}
{{Parent|Présentation des directives pragma - Index}}

==Syntaxe <span style="font-size: 60%">(voir [[Pseudo-grammaire|Pseudo-grammaire]])</span>==

'''Chaîne d'outils classique''' :

#pragma alias "aliasName" = "substituteName"

'''Chaîne d'outils Clang''' :<br />
la directive <code>#pragma alias</code> n'est pas supportée par les compilateurs [[BCC64X|BCC64X]] et [[Compilateurs Win32 améliorés par Clang|BCC32C]]. A la place, vous pouvez laisser un commentaire pour le lieur en procédant comme suit :<br />

#pragma comment(linker, "/alternatename:<name1><nowiki>=</nowiki><name2>")

==Description==

<code>#pragma alias</code> indique au lieur que deux noms d'identificateurs sont équivalents. Les deux identificateurs doivent être saisis entre guillemets. Sinon, un avertissement [[W8086 Utilisation incorrecte de l'alias pragma "NomAlias"="NomSubstitué" (C++)|W8086 Utilisation incorrecte de l'alias pragma "aliasName"="substituteName" (C++)]] est émis.

Les alias sont à présent gérés dans des unités distinctes, par deux fichiers .obj, un pour Unicode et un pour non-Unicode. Ces deux fichiers .obj font partie de la bibliothèque VCL.

Le <code>NomAlias</code> et le <code>NomSubstitué</code> sont injectés dans leur fichier .obj correspondant, exactement comme ils sont écrits à l'intérieur des guillemets. Le lieur recherche toutes les références à <code>NomAlias</code> et les lie au <code>NomSubstitué</code>.

{{Note| Les [[Fichier d'en-tête C++ (*.h, *.hpp)|fichiers .hpp]] générés depuis le code {{Delphi}} utilisent l'alias <code>#pragma</code> pour la gestion des identificateurs qui sont substantypés différemment dans {{Delphi}} et {{CBuilder}}.}}

[[Category:Référence C++]]
[[Category:C++]]

WebStencils

Yukikoi — Fri, 09 Oct 2026 18:47:07 GMT

Yukikoi a importé WebStencils par téléversement de fichier (1 version) LOC-23451

Nouvelle page

WebStencils, un système d'intégration et de traitement des fichiers HTML côté serveur, a été introduit dans {{Product}} version 12.2 pour les technologies WebBroker et RAD Server. Cette fonctionnalité flexible permet aux développeurs de concevoir des sites web modernes basés sur n'importe quelle bibliothèque JavaScript tout en exploitant les données extraites et traitées par une application serveur RAD Studio. Cette technologie offre une grande flexibilité pour créer des sites web adaptés à vos besoins spécifiques.

WebStencils a pour objectif de faciliter la création de sites de navigation par l'adoption des technologies Web (WebBroker, DataSnap, RAD Server) en fournissant des scripts côté serveur. Il est ainsi possible de générer des pages HTML avec des outils standard et d'utiliser n'importe quelle bibliothèque CSS et JavaScript tout en ajoutant des données à partir des pages générées depuis l'application (il peut s'agir par exemple du résultat d'une requête de base de données).

De plus, WebStencils constitue une excellente base pour le développement Web avec HTMX. Les pages HTMX bénéficient de la génération de code côté serveur et peuvent se connecter à des serveurs REST pour la mise à jour du contenu. Les technologies Web de Delphi offrent des fonctionnalités de génération de page et d'API REST de très haut niveau.

==Syntaxe de WebStencil==

Le langage de script de WebStencils repose sur deux éléments et est relativement simple :

* Le {{code|'''@''' }}
* Les accolades {{code| '''{ }''' }}

===Utilisation du symbole {{code|@}}===

WebStencils utilise le symbole {{code|'''@'''}} comme marqueur spécial plutôt que des balises HTML/XML ou d'autres notations. Le symbole {{code|'''@'''}} est suivi par :

* Le nom d'un objet ou d'un champ.
* Un [[WebStencils#Mots clé de WebStencils|mot clé spécial]].
* Un autre symbole {{code|'''@'''}}. {{Tip| L'utilisation du symbole {{code|'''@'''}} est plus souple. Ainsi, vous n'aurez pas besoin de le doubler dans certaines situations, comme dans les en-têtes.}}

L'accès général à une valeur est basé sur une notation par point, sous la forme object.value. C'est pourquoi vous observerez des balises comme :

@object.value

Le nom de '''l'objet''' est un nom symbolique local qui peut correspondre à un objet réel d'une application serveur, assigné à l'exécution du script via un processus de recensement. Il peut aussi être résolu dans le code lors du traitement d'un gestionnaire d'événement OnGetValue.

La valeur est composée du nom de la propriété (pour un objet générique), du nom d'un champ (si l'objet hérite de TDataSet), et d'une chaîne qui est transmise dans le gestionnaire d'événement OnGetValue associé au processeur.

{{Note|La sortie des valeurs traitées par WebStencils est chiffrée avec la méthode TNetEncoding.HTML.Encode. Vous pouvez supprimer le chiffrement en utilisant la syntaxe {{code|@\value}}.}}

====Accès aux ensembles de données et objets imbriqués====

Vous pouvez aussi utiliser le symbole {{code|'''@'''}} pour accéder à des ensembles de données et des objets imbriqués en utilisant la syntaxe suggérée dans les scénarios suivants :

* Objets et classes imbriqués :<source lang="delphi">
@MyObject.SubObject.ProperyName</source>
* Tables dans les ensembles de données imbriqués :<source lang="delphi">
@MyDataSet.DataSetField.SubField</source>

===Utilisation des accolades pour les blocs {{code|{}}}===

La seconde notation utilise des accolades, {{code|{}} et {{code|}}}, pour indiquer les blocs conditionnels ou répétés.

Toute autre utilisation des accolades dans le fichier de code source (le fichier HTML) est ignorée. En d'autres termes, les accolades ne sont traitées que si elles sont utilisées après une instruction conditionnelle WebStencils spécifique.

===Accès à des valeurs avec la notation par point===

Prenons en exemple l'extrait de code HTML WebStencils ci-dessous :<source lang="delphi">
<h2>GetValue</h2>
<p>Value obtained from data: @data.name</p>
<p>Value obtained with request @@data.value: @data.value</p></source>

Les symboles {{code|@@}} sont ignorés (nous attendons un seul {{code|@}} en sortie). Il suffit d'un seul pour déclencher le traitement.
Notez également que les deux symboles, le nom d'objet et le nom de valeur, doivent être des identificateurs Delphi valides et ne peuvent pas contenir d'espaces ni commencer par un chiffre. Un nom peut contenir des caractères de soulignement et des chiffres.

===Gestionnaire d'événement OnValue===

Il est possible de fournir des données en utilisant un composant avec le gestionnaire d'événement OnValue. Par exemple :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebStencilsValueFromEventValue(Sender: TObject;
const ObjectName, FieldName: string; var ReplaceText: string;
var Handled: Boolean)
begin
if SameText (ObjectName, 'data') then
begin
Handled := True;
ReplaceText := 'You requested ' + FieldName;
end;
end;</source>

Dans le code exemple ci-dessus, le code vérifie uniquement le nom d'objet (la première partie du symbole avant le point), mais il est recommandé de vérifier également la propriété FieldName (le symbole après le point).

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebStencilsValueFromEventValue(TObject *Sender,
const String ObjectName, const String FieldName, String &ReplaceText, bool &Handled)
{
if (SameText(ObjectName, "data"))
{
Handled = true;
ReplaceText = "You requested " + FieldName;
}
}</source>

Dans l'exemple ci-dessus, {{code|String}} est une chaîne {{code|UnicodeString}} compatible Delphi dans C++ Builder. {{code|SameText}} est une fonction de comparaison de chaînes insensible à la casse fournie par SysUtils. Enfin, {{code|&ReplaceText}} et {{code|&Handled}} sont transmis par référence pour permettre la modification et reproduire le comportement {{code|var}} de Delphi.

===Utilisation d'un objet dans le dictionnaire de variables de script===

Une autre approche consiste à fournir les valeurs en utilisant un objet. Dans ce cas, l'objet doit être configuré et associé à l'action du producteur.

Voici un exemple complet, supposant une classe TMyObject et sa propriété Name :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule1.WebModule1WebActionItem2Action(Sender: TObject;
Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
begin
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetValue</h2>
<p>Value obtained from data: @world.Name</p>
''';
var MyObj := TMyObject.Create();
MyObj.Name := 'Hello hello';
WebStencilsProcessor1.AddVar('world', MyObj, True);
Response.Content := WebStencilsProcessor1.Content;
Handled := True;
end;</source>

Cet exemple donne le résultat suivant :

"Value obtained from data: Hello Hello"

Notez que l'objet est recensé avec le nom 'world', qui sera ensuite utilisé dans le script WebStencils.

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule1::WebModule1WebActionItem2Action(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
WebStencilsProcessor1->InputLines->Text =
"<h2>GetValue</h2>\n"
"<p>Value obtained from data: @world.Name</p>";

TMyObject *MyObj = new TMyObject();
MyObj->Name = "Hello hello";

WebStencilsProcessor1->AddVar("world", MyObj, true);

Response->Content = WebStencilsProcessor1->Content;
Handled = true;
}</source>

===Expressions===

Voici la liste des expressions prises en charge :

*{{code|'''@ (<expression>)'''}} - marqueurs de variable. L'expression doit être écrite entre parenthèses.
*{{code|'''@if (<expression>)'''}} - commande "if". L'expression doit être écrite entre parenthèses.
*{{code|'''@Import (<expression>)'''}}, {{code|'''@LayoutPage (<expression>)'''}}, {{code|'''@AddPage (<expression>)'''}} - ''commandes de fichier. L'expression doit être écrite entre accolades.''

L'exemple suivant montre uniquement les différences entre les options ci-dessus :<source lang="delphi">
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetExpression</h2>
<p>Value obtained from data: @(world.value*2)</p>
''';
MyObj.Value := 2;</source>

Vous obtenez alors la sortie suivante :

"Value obtained from data: 4"

En plus des expressions simples, vous pouvez étendre le système en utilisant des appels de fonction personnalisés. Voici un exemple de code qui recense une fonction “'''Concat'''” recevant deux paramètres chaîne :<br />'''Delphi :'''<source lang="delphi">
uses
System.Bindings.EvalProtocol, System.Bindings.Methods;

TBindingMethodsFactory.RegisterMethod(
TMethodDescription.Create(
MakeInvokable(function(Args: TArray<IValue>): IValue
begin
Result := TValueWrapper.Create(
Args[0].GetValue.AsString + Args[1].GetValue.AsString);
end),
'Concat', 'Concat', '', True, '', nil));</source>

Dans un script WebStencils, vous pouvez l'utiliser dans une expression comme :

@(Concat('aaa', 'bbb']]

'''C++ :'''<source lang="cpp">
#include <System.Bindings.EvalProtocol.hpp>
#include <System.Bindings.Methods.hpp>
#include <System.Rtti.hpp>
#include <System.SysUtils.hpp>

using namespace System::Bindings::EvalProtocol;
using namespace System::Bindings::Methods;
using namespace System::Rtti;

class TValueWrapper : public TInterfacedObject, public IValue
{
private:
TValue FValue;

public:
__fastcall TValueWrapper(const TValue &AValue) : FValue(AValue) {}

virtual TValue __fastcall GetValue() { return FValue; }

// Implement other IValue methods as needed...
};

void RegisterCustomBindingMethod()
{
TBindingMethodsFactory::RegisterMethod(
new TMethodDescription(
MakeInvokable([](const TArray<IValue*> &Args) -> IValue*
{
String s1 = Args[0]->GetValue().ToString();
String s2 = Args[1]->GetValue().ToString();
return new TValueWrapper(TValue::From<String>(s1 + s2));
}),
"Concat", "Concat", "", true, "", nullptr));
}</source>

====Instruction Switch====

En plus de l'instruction {{code|@if}}, les utilisateurs peuvent choisir d'utiliser les instructions {{code|@switch}} ou {{code|@case}}.<br />
Voici un exemple de syntaxe :<source>
@switch(@user.role) {
@case "admin" {
<div>Admin Panel</div>
} @case "moderator" {
<div>Moderator Tools</div>
} @default {
<div>Regular User View</div>
}
}</source>

A partir de l'exemple ci-dessus, notez que :

*Les valeurs des "case" peuvent être des littéraux ou des expressions utilisant {{code|@}}(expression).
*Seul le premier "case" correspondant est exécuté.
*L'utilisation de {{code|@default}} est facultative et s'exécute s'il n'y a pas de correspondance avec "case"'.

===Utilisation d'un ensemble de données===

Une alternative consiste à utiliser l'enregistrement en cours d'un ensemble de données plutôt qu'un objet. Dans ce cas, votre code sera comme suit :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebModule13waCompanyAction(Sender: TObject;
Request: TWebRequest; Response: TWebResponse;
var Handled: Boolean];
begin
ClientDataSet1.Open;
if not WebStencilsValueFromObject.InVars ('dataset'] then
WebStencilsValueFromObject.AddVar(
'dataset', ClientDataSet1, False]; // False = do not destroy
Response.Content := WebStencilsValueFromObject.Content;
ClientDataSet1.Close;
end;</source>

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebModule13waCompanyAction(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
ClientDataSet1->Open();

if (!WebStencilsValueFromObject->InVars("dataset"))
{
WebStencilsValueFromObject->AddVar("dataset", ClientDataSet1, false); // false = do not destroy
}

Response->Content = WebStencilsValueFromObject->Content;

ClientDataSet1->Close();
}</source>

Le code HTML correspondant peut contenir des références à certains champs de l'enregistrement. Voici un exemple de résultat :<source lang="delphi">
<div class="list-group w-50">
@foreach dataset {
<a href="/company?id=@loop.custno" class="list-group-item
list-group-item-action" aria-current="true">
<div class="d-flex w-100 justify-content-between">
<h5 class="mb-1">@loop.company</h5>
<small>@loop.country</small>
</div>
<p class="mb-1">@loop.city</p>
<small>@loop.state</small>
</a>
}</source>

====Accès aux propriétés de l'ensemble de données====

La notation WebStencils {{code|@}} relative à un ensemble de données permet d'accéder aux propriétés de l'ensemble de données, en plus de ses champs. Les utilisateurs peuvent utiliser {{code|@data.RecordCount}} pour accéder à la propriété RecordCount. En cas de conflit, les champs de l'ensemble de données ont priorité sur les propriétés portant le même nom.

Cela inclut l'accès aux informations des champs, comme suit :

@foreach field in customers.fields

Ainsi que l'accès aux propriétés des champs :<source>
@foreach customer in customers {
@customer.address.visible
@customer.phone.displaylabel
}</source>

==Utilisation de variables de modules==

Alternativement, pour recenser un objet spécifique pour un WebStencilsProcessor, vous pouvez ajouter un “'''module'''” avec plusieurs objets. Dans ce contexte, un 'module' est une collection d'objets ou de fonctions liés entre eux. N'importe quel champ ou n'importe quelle propriété du module peut être décoré avec l'attribut {{code|'''[WebStencilsVar]'''}}, qui vous permet de spécifier comment le WebStencilsProcessor doit traiter les données.

Par exemple, supposons que votre module de données a un composant FDMemTable1 de type TFDMemTable marqué comme {{code|'''[WebStencilsVar]'''}}, et un champ LastName, vous pouvez écrire :

<source lang="delphi">

WebStencilsProcessor1.InputLines.Text := '''
<h2>GetTableData</h2>
<p>Value obtained from table: @(FDMemTable1.LastName)</p>
''';
WebStencilsProcessor1.AddModule(self);</source>L'exemple ci-dessous renvoie la valeur de LastName dans le premier enregistrement. Utilisez une boucle {{code|'''@for'''}} pour afficher tous les enregistrements.

===Utilisation de variables supplémentaires===

Ajoutez des variables supplémentaires au moteur de script à l'extérieur des modèles d'objet et d'ensemble de données. Plutôt que d'ajouter une structure de données spécifique, ce mécanisme propose une méthode anonyme qui permet d'implémenter une recherche personnalisée dans une structure de données personnalisée. Il s'agit des méthodes suivantes :

TWebStencilsDataVars.Add(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsProcessor.AddVar(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsEngine.AddVar(LookupFunc), AddInitFunc(LookupFunc)

Voici un exemple :

<source lang="delphi">
type
TMap = TDictionary<string, string>;
var
LDict: TMap;
begin
LDict := TMap.Create;
LDict.Add('APP_VERSION', '1.0.0');
LDict.Add('APP_NAME', 'WebStencils demo');
LDict.Add('COMPANY_NAME', 'Embarcadero Inc.');
LDict.Add('DEBUG_MODE', 'True');

FWebStencilsProcessor.AddVar('env', LDict, True,
function(AVar: TWebStencilsDataVar; const APropName: string;
var AValue: string): Boolean
begin
Result := TMap(AVar.TheObject).TryGetValue(APropName.ToUpper, AValue);
end);</source>

Vous pouvez aussi l'utiliser dans un modèle, comme suit :

<source>
@env.APP_NAME - @env.APP_VERSION
@if env.DEBUG_MODE {
<div>Debug mode active</div>
}</source>

==Mots clés de WebStencil==

Le moteur WebStencils utilise les balises suivantes sous forme de mots clés (notez que ces noms ne peuvent pas être utilisés pour des variables de script).

{| class="wikitable"
|-
!Mot clé
!Description
|-
|{{code| '''@query'''}}
|Utilisé pour lire des paramètres de requête HTTP.
|-
|{{code| '''@page'''}}
|Fournit l'accès au nom de la page et aux arguments de l'URL (voir la propriété [[WebStencils#Utilisation de WebStencils avec RAD Server|PathTemplate]] pour plus d'informations). Il est possible d'accéder au chemin de l'URL en utilisant l'une de ces valeurs :
*{{code|@page.request_path}}
*{{code|@page.request_segment}}
|-
|{{code| '''@lang'''}}
|Utilisé pour la prise en charge de la traduction, déclenche un événement OnLang distinct plutôt que l'événement OnValue.
|-
|{{code| '''@* .. *@'''}}
|Utilisé pour ajouter des commentaires dans le script, qui seront omis dans le HTML résultant.
|-
|{{code| '''@if'''}} object.value { … } ['''@else''' { … }]
|Exécute le bloc suivant entre accolades uniquement si la valeur vaut {{code|true}}.
|-
|{{code| '''@if (<expression>)'''}}
|Utilisé pour restituer du contenu de façon conditionnelle. Si l'expression est évaluée à {{code|true}}, le contenu associé est inclus dans la sortie ; sinon il est omis.
|-
|{{code| '''@if not''' object.value { ... } ['''@else''' { … }]}}
|Exécute le bloc suivant entre accolades uniquement si la valeur ne vaut pas {{code|true}}. <br />Par exemple :
<source lang="delphi">
@if obj1.ValueBelowTen {
<p>@obj1.name <span> has a value of </span> @obj1.value</p>
}</source>
|-
|{{code| '''@ForEach''' (var object in list) { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement :
*Les ensembles de données
*TObjectList, doit être ajouté au dictionnaire de processeur.
*Tout objet possédant la méthode GetEnumerator, où l'énumérateur renvoie une valeur d'objet.
|-
|{{code| '''@ForEach''' object { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement les ensembles de données et TObjectList, qui doivent être ajoutés en tant que variables de script.
|-
|{{code|'''@loop'''}}
|Utilisez à l'intérieur d'un bloc pour faire référence à l'élément en cours de l'énumération (liste ou ensemble de données). Il doit être suivi du nom d'une propriété ou d'un champ sans utiliser de nom d'objet.
|-
|{{code|'''@Import'''}}
|Permet de fusionner un fichier externe à un emplacement spécifique du fichier externe. Suppose toutefois que le nom de fichier ait l'extension .HTML. <br />Le format doit être comme suit :
<source lang="delphi">
@import filename [ {<alias1> = <var1> [..., <aliasN> = <varN>]} ]</source>
|-
|{{code|'''@Scaffolding'''}}
|Espace réservé pour le scaffolding. Ce mécanisme permet de générer dynamiquement du code HTML à partir de la structure de données d'une application (les propriétés d'un objet et les champs d'une base de données). Le code HTML généré côté serveur peut inclure d'autres balises pour accéder aux données. <br />Le code suivant est un exemple de disposition HTML simple générée dans le gestionnaire d'événement OnScaffolding pour chacun des champs de la base de données.
<source lang="delphi">
procedure TWebModule1.ProcessorCompanyScaffolding(Sender: TObject;
const AQualifClassName: string; var AReplaceText: string);
begin
if SameText (AQualifClassName, 'Company') then
begin
AReplaceText := '';
for var I := 0 to ClientDataSet1.Fields.Count -1 do
AReplaceText := AReplaceText + '<p>'+
ClientDataSet1.Fields[I].FieldName +
': @dataset.' + ClientDataSet1.Fields[I].FieldName + '</p>';
end;
end;</source>
|-
|{{code|'''@switch'''}}, {{code|'''@case'''}}, {{code|'''@default'''}}
|Effectue un rendu conditionnel à branches multiples. Après avoir évalué une expression, la met en correspondance avec les valeurs définies avec @case, en restituant le bloc correspondant. La directive @default est utilisée si aucune correspondance n'est trouvée pour @case.
|-
|{{code|'''@LoginRequired'''}}
|Arrête l'exécution si une connexion est requise alors que l'utilisateur n'est pas connecté.
|-
|{{code|'''@LoginRequired (<role>)'''}}
|Le moteur vérifie que l'utilisateur est connecté, mais aussi qu'il dispose du rôle spécifique actif, ce qui restreint l'accès à la page selon la permission.<br /> Par exemple : '''@LoginRequired (admin)'''
|}

===Alias d'importation===

L'exemple ci-dessous illustre comment utiliser des alias d'importation.<source lang="delphi">
@import one {@o1 = @object, @d1 = @data} Hello</source>

Dans ce code, '''@object''' et '''@data''' sont les véritables variables dans le script exécuté. Les alias '''@o1''' et '''@d1''' sont des variables de script pour le script "one" et sont accessibles dans ce script comme des variables normales. Ainsi, vous pouvez transmettre au script QA des variables portant des noms différents, en fournissant comme alias le nom attendu par le script.

==Modèles WebStencils : disposition et corps==

La capacité à fusionner un modèle HTML partagé avec le contenu d'une page compte parmi les fonctionnalités indispensables d'un moteur de modèle. Cette opération s'effectue (comme dans la version .NET) en utilisant quatre symboles spéciaux :

* '''@LayoutPage filename''' : cette commande est utilisée dans une page HTML spécifique (généralement en haut de page) pour indiquer le fichier de modèle à utiliser comme structure de la page. Plusieurs pages peuvent partager un même modèle, mais toutes les pages d'un projet (même en utilisant TWebStencilsEngine) ou d'un dossier virtuel n'ont pas nécessairement besoin d'utiliser le même modèle.

:{{Note| Cette commande ne doit être utilisée qu'une seule fois par page. Si vous tentez d'utiliser plusieurs fois '''@LayoutPage''', une exception se déclenche et bloque la commande.}}

* '''@RenderBody''' : cette commande sans paramètre est une marque de réservation dans un fichier de modèle qui indique où placer le contenu d'une page spécifique.

Voici un exemple d'utilisation de '''@LayoutPage''' et de '''@RenderBody''' :

'''Test.html'''<source lang="delphi">
@LayoutPage BaseTemplate
<h2>Page Test3</h2>
<p>Local data param one is @page.name (the page name)</p></source>

'''BaseTemplate.html'''<source lang="delphi">
<html lang="en">
<head>

@extends layouts/intermediate
@ExtraHeader {
<style>.highlight { color: green; }</style>
}


@extends layouts/base
@ExtraHeader {
<meta name="viewport" content="width=device-width, initial-scale=1">
}


<head>
@RenderHeader
</head></source>

Dans l'exemple ci-dessus, le CSS de {{code|page.html}} et la balise meta de {{code|intermediate.html}} sont injectés dans la sortie finale de {{code|@RenderHeader}}.

==Composants de WebStencils==

Le package WebStencils installe deux composants différents : un processeur de fichier unique et un moteur qui instancie des processeurs individuels et fournit une configuration globale pour les processeurs autonomes ou ceux auxquels ils sont manuellement connectés.

Le composant principal prend un fichier HTML, incorpore la notation WebStencils et le convertit en HTML brut après avoir traité les balises {{code|'''@'''}}.

La classe '''TWebStencilsProcessor''' traite un fichier individuel (généralement ayant une extension HTML) et son modèle associé, le cas échéant. Le processeur peut être utilisé de façon autonome et assigné au '''TWebActionItem.Producer''', ou être créé et appelé par TWebStencilsEngine en tant que post-processeur de fichiers texte renvoyés par un répartiteur de fichiers.

===Composant WebStencilsEngine===

Le composant '''Engine''' peut être utilisé dans les deux scénarios suivants :

*Pour le connecter à un ou plusieurs composants '''WebStencilsProcessor''' et fournir des comportements et des paramètres partagés.
*Pour créer des composants '''WebStencilsProcessor''' lorsque cela est nécessaire, et placer uniquement ce composant sur vos modules web.

==Intégration automatique de sessions==

Lorsqu'elles sont disponibles, [[WebStencils|WebStencils]] peut automatiquement s'intégrer à des sessions web. Aucune configuration supplémentaire n'est nécessaire. Tout se fait automatiquement dès lors que {{code|WebRequest.Sessions}} existe.

Les données des sessions sont accessibles via {{code|@session.property}}. Tous les objets dans {{code|WebRequest.Session.DataVars}} sont automatiquement recensés en tant que variables de modèles. De même, {{code|UserLoggedIn}} et {{code|UserRoles}} sont automatiquement remplis à partir de {{code|WebRequest.Session.User}}.

En voici un exemple :<source>
@if session.Authenticated {
<div>User authenticated</div>
@session.sessionid
}

@if session.UserHasRole(‘admin’) {
<div>User is an Admin</div>
}</source>

==Liste blanche de sécurité==

Pour des raisons de sécurité, WebStencils implémente un mécanisme de liste blanche de propriétés pour éviter l'exposition d'informations sensibles comme les chaînes de connexion aux bases de données. Par défaut, seules les propriétés sécurisées sont accessibles. Voici la liste des propriétés sécurisées :

*Pour les '''TDataSet''' : Active, FieldByName, First, Last, Next, Prior, Bof, Eof, FieldCount, Fields, Found, RecordCount, RecNo.
*Pour les '''TStrings''' : Contains, ContainsName, IndexOf, IndexOfName, CommaText, Count, IsEmpty, DelimitedText, Names, KeyNames, Values, ValueFromIndex, Strings, Text.

===Personnalisation de la liste blanche===

La liste blanche peut être personnalisée en utilisant la propriété [[lib_fr:Web.Stencils.TWebStencilsProcessor.Whitelist|TWebStencilsProcessor.Whitelist]]. La méthode de configuration permet aux utilisateurs de spécifier les membres autorisés et ceux bloqués. Voir l'exemple ci-dessous :<source>
procedure Configure(const AClass: <PTypeInfo, TClass, TObject>;
const AAllowedMembers: TArray<string>;
const ABlockedMembers: TArray<string>;
AReset: Boolean);</source>

* '''AClass''' : le type PTypeInfo/TClass/TObject pour configurer des éléments tels que des TDataSet, TStrings.
* '''AAllowedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite autoriser.
* '''ABlockedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite bloquer.
* '''AReset''' : {{code|True}} lorsqu'utilisé pour remplacer une liste blanche existante, ou {{code|False}} pour ajouter des éléments à la liste.

Voici un exemple qui illustre comment ajouter des membres autorisés supplémentaires à une liste blanche existante :<source>
TWebStencilsProcessor.Whitelist.Configure(TMyClass,
['CustomProp'], nil, False);</source>

Voici un exemple qui illustre comment remplacer la totalité d'une liste blanche (AReset = True) :<source>
TWebStencilsProcessor.Whitelist.Configure(TDataSet,
['RecordCount', 'RecNo'], nil, True);</source>

Voici un exemple qui illustre comment bloquer certains membres :<source>
TWebStencilsProcessor.Whitelist.Configure(MyObject,
nil, ['CustomProp'], False);</source>

La liste blanche s'applique à l'ensemble de l'application et à tous les WebStencils.

==Utilisation de WebStencils avec RAD Server==

La bibliothèque de modèles WebStencils peut aussi être utilisée dans une application RAD Server. Il est recommandé de combiner le composant ''TEMSFileResource''' existant avec un composant '''TWebStencilsEngine'''. Le premier permet de mapper le système de fichiers, alors que le second gère le mappage HTTP et le traitement des modèles. Les composants sont connectés en utilisant la propriété Dispatcher du moteur WebStencil.

L'exemple ci-dessous illustre la configuration nécessaire pour ajouter deux composants à un module web RAD Server :<source lang="delphi">
object html: TEMSFileResource
PathTemplate = '..\..\html\{filename}'
end
object WebStencilsEngine1: TWebStencilsEngine
Dispatcher = html
PathTemplates = <
item
Template = '/'
Redirect = '/test1.html'
end
item
Template = '/list'
Redirect = '/companylist.html'
end
item
Template = '/company'
OnPathInit = WebStencilsEngine1PathTemplates2PathInit
end
...>
end</source>

Les PathTemplates sont utilisés pour mapper les URL entrantes à des fichiers. En mode conception, la configuration se présente comme suit :

[[File:PathTemplates WebStencils.png|350px|=link]]

De plus, il est nécessaire de configurer le mappage de plus haut niveau dans le module de données :

<source lang="delphi">
type
[ResourceName('testfile')]
TTestfileResource1 = class(TDataModule)
[ResourceSuffix('./')]
[ResourceSuffix('get', './')]
[EndpointProduce('get', 'text/html')]
html: TEMSFileResource;</source>

Pour mapper plusieurs chemins différents (à la différence de l'exemple ci-dessus), ajoutez des composants '''TEMSFileResource'''. Le composant '''TWebStencilsEngine''' peut comporter un seul dispatcher dans la propriété correspondante. Pour associer davantage de dispatchers, utilisez le code suivant :

<source lang="delphi">
AddProcessor(html2, WebStencilsEngine1);</source>

==Voir aussi==

*[[Présentation de RAD Server|Présentation de RAD Server]]

Fractionnement de l'éditeur

Yukikoi — Fri, 09 Oct 2026 18:47:06 GMT

Yukikoi a importé Fractionnement de l'éditeur par téléversement de fichier (1 version) LOC-23451

Nouvelle page

La vue [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] permet d’utiliser plusieurs éditeurs côte à côte, les uns au-dessus des autres, ou de façon combinée, le tout dans une même fenêtre. Cela inclut la possibilité de faire glisser des ensembles d'onglets vers des fenêtres flottantes, puis de les replacer dans l'EDI.
Elle permet aussi d'avoir plusieurs dispositions personnalisées et offre diverses possibilités de manipulation : disposition simple en deux colonnes, disposition sur plusieurs lignes, ou une configuration particulièrement adaptée à votre flux de travail.
Vous pouvez travailler en ayant plusieurs onglets ouverts, et ouvrir la même unité dans chacun de ces onglets. Vous pouvez aussi avoir plusieurs onglets ouverts : l'un avec le concepteur de fiche et plusieurs autres avec le code de l'unité correspondante. L'onglet contenant le concepteur de fiche peut aussi être déplacé.
Il n'y a '''aucune limite''' quant au nombre de vues fractionnées, que ce soit horizontalement ou verticalement.

===Utilisation du fractionnement de l'éditeur===

Vous pouvez accéder à la vue Fractionnement de l'éditeur en cliquant avec le bouton droit sur un onglet et en choisissant '''Fractionner >''' ou '''Déplacer >'''. Le fractionnement crée une nouvelle version de l'onglet sélectionné, et le déplacement provoque son ouverture à l'endroit sélectionné dans l'EDI.

[[File:Using-spliteditor.png|=link|400px|border]]

Les raccourcis suivants peuvent être utilisés pour les deux options :

*'''Fractionner en haut :''' Alt+Maj+T
*'''Fractionner en bas :''' Alt+Maj+B
*'''Fractionner à droite :''' Alt+Maj+R
*'''Fractionner à gauche :''' Alt+Maj+L
*'''Déplacer en haut :''' Ctrl+Alt+Maj+T
*'''Déplacer à gauche :''' Ctrl+Alt+Maj+L
*'''Déplacer à droite :''' Ctrl+Alt+Maj+R
*'''Déplacer en bas :''' Ctrl+Alt+Maj+B

Alternativement, vous pouvez utiliser [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] en faisant glisser un fichier de la vue Projets dans un onglet de l'éditeur. Vous pouvez aussi effectuer un clic droit sur le fichier du projet, puis sélectionner l'option '''Ouvrir dans''' et choisir l'onglet de l'éditeur dans lequel vous souhaitez ouvrir le fichier.

Lorsque deux onglets sont dans une fenêtre, chacun a une barre de titre.

Le fractionnement de l'éditeur vous permet de :

*Faire glisser un onglet de l'éditeur, ou un ensemble d'onglets, en faisant glisser la barre de titre et en l'ancrant sur n'importe quel côté de la fenêtre de l'EDI.
*Le faire glisser et l'ancrer sur n'importe côté de l'éditeur (gauche, droit, haut, bas).
*Le fusionner avec un ensemble d'onglets en le faisant glisser au centre d'un éditeur existant, y compris une fenêtre flottante d'onglets.
*Le faire glisser en dehors de sa propre fenêtre (soit un seul onglet ou un ensemble d'onglets).

La plupart des opérations peuvent être réalisées sur des onglets individuels. Il peut s'agir par exemple de déplacer un onglet entre des ensembles d'onglets ancrés en faisant glisser l'onglet individuel d'un emplacement à un autre.

Chaque ensemble d'onglets peut être déplacé à l'extérieur de sa propre fenêtre. Faites glisser la barre de titre pour le déplacer.
{{Tip| Vous pouvez appuyer sur Ctrl tout en faisant glisser l'ensemble d'onglets pour vous assurer qu'il ne s'ancre pas.}}

De la même façon, chaque fenêtre peut être ancrée à côté d'un autre ensemble d'onglets. Pour cela, vous devez faire glisser la barre de titre.

{{Note|La plupart des éditeurs/groupes disparaissent de la vue lorsqu'ils sont fermés. Toutefois, la fermeture du premier éditeur (celui qui était auparavant l'éditeur de la fenêtre principale) avec le bouton ‘X’ provoque la fermeture de tous les onglets qu'il contient. L'espace qu'il occupait reste ouvert, car l'éditeur original ne peut pas être fermé. Cela n'a aucune incidence tant que les groupes d'onglets ne sont pas fermés. Il n'y a aucun impact visible lorsque vous créez, déplacez ou ancrez les onglets dans vos tâches.}}

[[File:Split Editor Example.png|800px|]]

''C'est l'une des nombreuses façons de configurer la vue Fractionnement de l'éditeur. Elle comporte une fenêtre d'édition sur la gauche, deux à droite, et les volets sont masqués mais apparaissent lorsqu'ils sont survolés par la souris.''

===Concepteur et code===

Les vues Fractionnement de l'éditeur permettent de modifier un même fichier dans deux fenêtres d'édition affichées côte à côte, chacune affichant le même contenu de fichier. Lorsque vous tapez dans l'une et que vous faites défiler le texte jusqu'à un emplacement, le texte apparaît dans l'autre fenêtre. Vous pouvez faire défiler les deux fenêtres indépendamment l'une de l'autre, ce qui permet de modifier le fichier à plusieurs endroits.
Vous pouvez ainsi ouvrir un même fichier dans autant d'onglets que vous le souhaitez.
{{Note|Gardez toujours à l'esprit qu'il n'y a qu'un seul fichier (module ou tampon de fichier en termes internes) affiché dans plusieurs vues. Ainsi, toute modification effectuée dans l'une de ces vues sera répercutée dans les autres vues (il ne s'agit pas de copier ou de dupliquer une modification). <br />
Autrement dit, toute modification de fichier depuis une fenêtre d'édition concerne le fichier lui-même et pas la fenêtre. Cette modification sera répercutée dans les autres vues. }}

===Conseils et astuces===

*'''Enregistrez''' la configuration des éditeurs en tant que disposition du bureau. Sinon, vous risquez de passer beaucoup de temps à définir une présentation qui ne sera pas sauvegardée.

{{Notes|

*Lorsque la disposition de bureau est modifiée, la configuration change également (par ex. lorsque l'EDI commence le débogage et passe en '''Disposition de débogage'''.
*Lorsque vous changez de disposition, tout groupe d'onglets qui ne trouve pas sa place dans la disposition est détaché et devient une fenêtre flottante.}}
*Activez '''Options''' > '''Enregistrement et récupération''' > '''Enregistrer le bureau du projet lors de la fermeture''' et '''Enregistrer l'état de l'éditeur à la fermeture d'un onglet'''.
*Lorsque vous enregistrez l'état de l'éditeur, vous enregistrez également la position de défilement, les zones réduites ou développées, etc. C'est très pratique lorsque plusieurs fenêtres d'édition du même fichier sont ouvertes. Ainsi, lorsque vous rouvrez votre bureau et rouvrez le projet (ou tout simplement, lorsque vous rouvrez un éditeur précédemment fermé), la nouvelle fenêtre d'édition s'affiche telle qu'elle était au moment de la fermeture.
*Pensez à désancrer les volets ancrables d'ancienne génération. Ils sont réduits sous forme de petit onglet sur un côté de la fenêtre principale. Vous pouvez les rendre visibles à nouveau en cliquant dessus, et ils restent affichés tant qu’ils ont la focalisation. Pour cela, vous devez cliquer sur le bouton d'épinglage dans la barre de titre du volet, à côté du bouton X. Cette fonctionnalité existe depuis de nombreuses années, mais elle n’était vraiment utile que lorsque l’espace à l'écran était limité. Maintenant que plusieurs fenêtres d'édition peuvent être fractionnées et ancrées ensemble, il devient très pratique de pouvoir désépingler les volets latéraux pour libérer de l’espace horizontal.
*Pensez à faire un clic droit sur un onglet '''> Fractionner > A droite''' (ou '''A gauche'''). L'utilisation de plusieurs colonnes est certainement la configuration la plus courante pour les vues fractionnées. Plus vous utiliserez cette fonctionnalité, plus vous constaterez son utilité.

==Voir aussi==

*[[Présentation de l'EDI|Présentation de l'EDI]]
*[[Aperçu et page d'accueil|Aperçu et page d'accueil]]

Importation et exportation de package pour la nouvelle chaîne d'outils C++

Yukikoi — Fri, 09 Oct 2026 18:13:08 GMT

Yukikoi a importé Importation et exportation de package pour la nouvelle chaîne d'outils C++ par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Packages pour la nouvelle chaîne d'outils C++}}

Lorsque le modificateur PACKAGE ou [[Declspec(package)|__declspec(package)]] est utilisé, il est difficile de comprendre quand les éléments sont importés ou exportés. {{Product}} applique des heuristiques et considère qu'une classe est traitée en tant que [[Declspec(dllexport)|__declspec(dllexport)]] lorsque les conditions suivantes sont réunies :

* La classe est marquée comme <code>[[Declspec(package)|__declspec(package)]]</code> et contient une déclaration de fonction non-inline.
* Le fichier qui contient la classe est compilé avec l'option <code>-tP</code>.

Sinon, la classe est considérée comme [[Declspec(dllimport)|__declspec(dllimport)]].

En résumé, il s'agit de '''suppositions'''. Il n'existe aucun moyen fiable de mapper une déclaration dans un fichier d'en-tête {{CBuilder}} pour savoir s'il doit être exporté ou importé, ce qui justifie l'application d'heuristiques. En règle générale, en présence d'une [[Declspec(package)|macro PACKAGE]] le compilateur suppose que le package essaie d'effectuer une exportation lors de la construction d'un projet de package. Il suppose sinon que c'est une importation.

Notez que nous utilisons des méthodes inline dans nos fichiers HPP. Elles concernent généralement les constructeurs, en raison des différences de disponibilité dans les classes descendantes ({{Delphi}} hérite de tous les constructeurs). Toutefois, ces méthodes n'empêchent pas une classe d'être importée selon les heuristiques. En bref, on retiendra que des heuristiques sont appliquées si [[Declspec(package)|__declspec(package)]] est utilisé.

La raison de ce comportement vient du fait que les packages tentent de transposer un concept {{Delphi}} en {{CBuilder}}, sans y parvenir parfaitement. En règle générale {{Product}} recommande d'utiliser les packages avec prudence. En privilégiant des usages qui correspondent à {{Delphi}} (comme c'est le cas avec les composants), vous aurez plus de chances de réussite que si vous utilisez un package de la même façon qu'une DLL, alors qu'il serait préférable d'utiliser une DLL ou une bibliothèque statique.

===Exemple de code===

{{#tag:syntaxhighlight|
class PACKAGE TMyComponent : public TComponent {
public:

__fastcall TMyComponent(TComponent* Owner);
void __fastcall DoSomething();

};

|lang=c++}}Dans cet exemple, la classe TMyComponent utilise la macro PACKAGE (qui est développée en decspec(package).) En conséquence, le compilateur applique des heuristiques pour déterminer si vous souhaitez exporter ou importer la classe.

==Recommandations==

Veuillez prendre en compte les recommandations suivantes lorsque vous utilisez l'importation et l'exportation de packages avec la nouvelle chaîne d'outils C++. Cela vous permettra d'éviter des problèmes.

* Evitez d'utiliser les méthodes générées par défaut ou générées par le compilateur dans une classe marquée comme package. Suivez la [https://en.cppreference.com/w/cpp/language/rule_of_three règle des trois/cinq].
* En toutes circonstances, vous ne devez pas utiliser les méthodes inline dans les types de vos packages importés ou exportés, même s'ils sont simples. Vous devez explicitement placer toutes les méthodes (y compris le constructeur/destructeur/constructeur de copie, et les [https://en.cppreference.com/w/cpp/language/rule_of_three autres]) dans le fichier .cpp.
* Nous vous recommandons fortement de ne pas exporter les types de templates, car ils sont par définition "inlinés" et peuvent provoquer des définitions multiples.
* Soyez prudent avec les dépendances entre unités, et apprenez à maîtriser [[Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++|l'initialisation et la finalisation des unités]].
* De manière générale, nous recommandons fortement de ne pas utiliser PACKAGE ou [[Declspec(package)|__declspec(package)]] sauf dans des usages très simples. A la place, nous vous conseillons de marquer manuellement vos types avec [[Declspec(dllimport)|__declspec(dllimport)]] et [[Declspec(dllexport)|__declspec(dllexport)]].<br /> {{Tip|Une autre approche consiste à wrapper les modificateurs dans une macro dont la valeur dépend de l'emplacement de l'en-tête. En d'autres termes, votre projet EXE peut définir une macro afin qu'une importation soit effectuée lorsque l'en-tête est inclus.}}
* Les packages étant des DLL étendues, ces directives dllimport/dllexport s'appliquent. Le point clé ici est qu'en les marquant explicitement, le compilateur n'a plus besoin de deviner, car il reçoit une directive claire du programmeur lui indiquant d'effectuer une importation ou une exportation. Les packages sont très pratiques pour les composants et utiles pour les types basés sur {{Delphi}}, mais il est préférable d'utiliser des DLL pour l'exécution dynamique. <br />{{Attention|Notez qu'il n'y a pas d'enracinement de type entre modules dans C++.}}

===Voir aussi===

* [[Packages pour la nouvelle chaîne d'outils C++|Packages pour la nouvelle chaîne d'outils C++]]
* [[Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++|Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++]]
*[[Declspec(dllimport)|__declspec(dllimport)]]
*[[Declspec(dllexport)|__declspec(dllexport)]]
*[[BCC64X|BCC64X]]

Chargement des packages dans une application

Yukikoi — Fri, 09 Oct 2026 18:13:08 GMT

Yukikoi a importé Chargement des packages dans une application par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Packages d'exécution}}

Vous pouvez charger dynamiquement les packages en utilisant l'une des procédures suivantes :

<ul><li>
Sélection de l'option '''Lier avec les packages d'exécution''' dans la boîte de dialogue '''Options de projet''' (comme décrit dans cette rubrique)</li>
<li>'''[[Chargement des packages avec la fonction LoadPackage|Chargement des packages avec la fonction LoadPackage]]'''</li>
</ul>

'''Pour charger des packages en utilisant la boîte de dialogue Projet > Options'''

<ol><li> Ouvrez ou créez un projet dans l'EDI.</li>
<li> Choisissez {{Menu|Projet > Options > Packages > [[Packages d'exécution (Options)|Packages d'exécution]]}}.</li>
<li> Activez la case à cocher '''Lier avec les packages d'exécution'''. </li>
<li> Passez en revue la liste des packages d'exécution connus dans le champ '''Bibliothèques d'importation des packages d'exécution'''.

{{Note| N'oubliez pas que les packages d'exécution associés aux packages de conception installés sont déjà listés. <br />De plus, les packages d'exécution sont chargés implicitement seulement quand c'est nécessaire (c'est-à-dire quand vous faites référence à un objet défini dans l'une des unités de ce package).}}

</li>
<li> Pour entrer des noms de bibliothèques supplémentaires, cliquez sur le champ '''Bibliothèques d'importation des packages d'exécution''', puis effectuez l'une des opérations suivantes :<ul><li>
Cliquez sur le bouton [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]], à l'extrémité droite du champ. Dans la boîte de dialogue '''Bibliothèques d'importation des packages d'exécution''', vous pouvez :<ul><li>Entrer le nom du nouveau package et cliquer sur '''Ajouter'''.</li>
<li>Parcourir la liste des packages disponibles en cliquant sur le bouton '''Rechercher un dossier''' dans la boîte de dialogue '''Bibliothèques d'importation des packages d'exécution'''. Cliquez ensuite sur le bouton '''Parcourir''' auprès de '''Nom du package''' dans la boîte de dialogue [[Ajouter un package d'exécution|Ajouter un package d'exécution]]. <br />
{{Note|Si vous éditez la zone d'édition '''Chemin de recherche''' dans [[Ajouter un package d'exécution|Ajouter un package d'exécution]], vous changez le '''chemin de bibliothèque global'''.}}</li>
</ul>
</li>
<li>
Entrez un ou plusieurs noms de packages dans le champ de saisie.<br />
{{Tip|Il n'est pas nécessaire d'inclure les extensions de fichiers dans les noms de packages (ou le numéro de version de la release {{Delphi}}) ; autrement dit, vcl90.bpl s'écrit vcl dans une application VCL. Si vous tapez directement dans la zone d'édition '''Package d'exécution''', séparez les noms par des points-virgules. Par exemple :<br /><source lang="cpp">
rtl;vcl;vcldb;vclado;vclbde;</source>}}</li>
</ul>
</li>
</ol>

Les packages listés dans la zone d'édition '''Packages d'exécution''' sont automatiquement liés à votre application lors de la compilation. Les noms de packages en double sont ignorés. De plus, si la case à cocher '''Lier avec les packages d'exécution''' est désactivée, l'application est compilée sans packages.
{{Tip| Pour C++, vous devez conserver les paramètres pour les packages dynamiques et utiliser la RTL dynamique de manière synchronisée. La chaîne d'outils utilisera la bibliothèque d'exécution dynamique si vous utilisez des packages, mais nous vous recommandons de vérifier et de maintenir la synchronisation dans {{Menu| Projet > Options > Packages > [[Packages d'exécution (Options)|Packages d'exécution]]}}.}}
Les packages d'exécution sont sélectionnés uniquement pour le projet en cours. Pour que les choix actuels deviennent les paramètres par défaut pour les nouveaux projets, cochez la case '''Par défaut''' en bas de la page Options de projet.
{{Note| Quand vous créez une application avec des packages, vous devez inclure les noms des unités {{Delphi}} originales dans la clause '''uses''' de vos fichiers source. Par exemple, le fichier source de votre fiche principale pourrait commencer ainsi :<source lang="delphi">
unit MainForm;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs;</source><source lang="cpp">
#include "vcldb.h"</source>}}
Les unités référencées dans cet exemple VCL sont contenues dans les packages VCL et RTL. Néanmoins, vous devez conserver ces références dans la clause '''uses''', même si vous utilisez VCL et RTL dans votre application. Vous risquez sinon d'obtenir des erreurs de compilation. Dans les fichiers source générés, le Concepteur de fiches ajoute automatiquement ces unités à la clause uses.

==Voir aussi==

*[[Choix des packages d'exécution à utiliser|Choix des packages d'exécution à utiliser]]
*[[Utilisation des packages et des composants - Présentation|Utilisation des packages et des composants - Présentation]]
*[[Déploiement des packages|Déploiement des packages]]
*[[Chargement des packages avec la fonction LoadPackage|Chargement des packages avec la fonction LoadPackage (construction avec des packages d'exécution)]]

[[Category:Guide du développeur Windows]]
[[Category:Delphi]]

Déclaration de variable inline

Yukikoi — Fri, 09 Oct 2026 18:13:08 GMT

Yukikoi a importé Déclaration de variable inline par téléversement de fichier (1 version) LOC-23451

Nouvelle page

Dans 10.3, le langage Delphi permet une plus grande souplesse dans la déclaration des variables locales. Jusqu'à maintenant, en conformité avec les règles du langage Pascal, toutes les déclarations de variables devaient être effectuées dans un bloc var qui était écrit avant le début d'une fonction, d'une procédure ou d'une méthode.<source lang="Delphi">
procedure Test;
var
I: Integer;
begin
I := 22;
ShowMessage (I.ToString);
end;</source>

La nouvelle syntaxe de déclaration des variables inline vous permet de déclarer la variable directement dans un bloc de code (tout en permettant d'utiliser plusieurs symboles).<source lang="Delphi">
procedure Test;
begin
var I: Integer;
I := 22;
ShowMessage (I.ToString);
end;

procedure Test2;
begin
var I, K: Integer;
I := 22;
K := I + 10;
ShowMessage (K.ToString);
end;</source>

Même si c'est un changement limité, il convient de signaler quelques effets secondaires. La déclaration et l'initialisation peuvent être effectuées dans une seule instruction. Vous pouvez déclarer des variables dans un bloc de code complexe avec une portée limitée (la variable est uniquement visible depuis l'emplacement de sa déclaration et il n'est pas nécessaire qu'elle soit déclarée et non initialisée pour la portion de code).

==Portée des variables inline==

Il existe un troisième effet secondaire : la déclaration est également autorisée au sein du bloc begin-end de deuxième niveau, la portée étant limitée à ce bloc.<source lang="Delphi">
procedure Test; // declaration and initialization in a single statement
begin
var I: Integer := 22;
ShowMessage (I.ToString);
end;

procedure Test1; // multiple inline declarations (symbols declared when used)
begin
var I: Integer := 22;
var J: Integer;
J := 22 + I;
var K: Integer := I + J;
ShowMessage (K.ToString);
end;

procedure Test2; // scope limited to local block
begin
var I: Integer := 22;
if I > 10 then
begin
var J: Integer := 3;
ShowMessage (J.ToString);
end
else
begin
var K: Integer := 3;
ShowMessage (J.ToString); // COMPILER ERROR: “Undeclared identifier: ‘J’”
end;
end;</source>

Comme vous pouvez le voir dans le dernier extrait de code ci-dessus, une variable déclarée à l'intérieur d'un bloc begin-end n'est visible qu'au sein de ce bloc spécifique, et ne l'est plus une fois le bloc terminé. A la fin des instructions if, J et K ne seront plus visibles.

L'effet secondaire ne se limite pas uniquement à la visibilité. Une variable managée, comme une référence d'interface ou un enregistrement, sera correctement nettoyée à la fin du bloc, plutôt qu'à la fin d'une procédure ou d'une méthode :<source lang="Delphi">
procedure Test99;
begin

// some code

if (something) then
begin
var Intf: IInterface = GetInterface; // Intf.AddRef
var MRec: TManagedRecord = GetMRecValue; // MRec.Create + MRec.Assign
UseIntf(Intf);
UseMRec(MRec);
end; // Intf.Release and MRec.Destroy are implicitly called at end of scope

// more code

end; // no additional cleanup</source>

==Inférence de type pour les variables inline==

De plus, le compilateur peut désormais inférer dans certaines circonstances le type d'une variable à l'emplacement de sa déclaration inline en examinant le type de la valeur qu'on lui a assigné.<source lang="Delphi">
procedure Test;
begin
var I := 22;
ShowMessage (I.ToString);
end;</source>

Le type de l'expression r-value (plus exactement, ce qui apparaît après  :=) est analysé pour déterminer le type de la variable. Certains des types de données sont “développés” vers un type plus large. Ainsi dans l'exemple ci-dessus, la valeur numérique 22 (un ShortInt) est développée en entier (Integer). En règle générale, le type de l'expression située à droite est un type entier et est inférieur à 32 bits, la variable sera déclarée comme un entier 32 bits. Vous pouvez utiliser un type explicite si vous voulez un type spécifique, numérique et inférieur.

Sachez également que seul un identificateur unique peut être déclaré sans type de valeur (à la différence des déclarations de variables générales et des déclarations inline).

Alors que cette fonctionnalité peut vous faire économiser quelques frappes de touche pour un entier ou une chaîne, l'inférence de type de variable peut s'avérer être très pratique pour les types complexes comme les instances de types génériques. Dans l'extrait de code ci-dessous, les types inférés sont “TDictionary<string, Integer>” pour la variable MyDictionary et “TPair<string, Integer>” pour la variable APair.

<source lang="Delphi">
procedure NewTest;
begin
var MyDictionary := TDictionary<string, Integer>.Create;
MyDictionary.Add ('one', 1);
var APair := MyDictionary.ExtractPair('one');
ShowMessage (APair.Value.ToString)
end;</source>

==Constantes inline==

En plus des variables, il est désormais possible de définir une déclaration de valeur constante comme étant inline. Cela s'applique aux constantes de types ou aux constantes non typées. Dans ce cas, le type est inféré (une fonctionnalité qui existe depuis longtemps pour les constantes). Voici un exemple :<source lang="Delphi">
const M: Integer = (L + H) div 2; // single identifier, with type specifier
const M = (L + H) div 2; // single identifier, without type specifier</source>

==Pour les boucles avec une déclaration de variable==

Les déclarations de variable inline s'avèrent particulièrement pratiques dans les instructions de boucle, y compris les boucles for-to et les boucles for-in.<source lang="Delphi">
for var I: Integer := 1 to 10 do ...
for var Item: TItemType in Collection do...</source>Vous pouvez simplifier le code en tirant parti de l'inférence de type :<source lang="Delphi">
for var I := 1 to 10 do ...
for var Item in Collection do ...</source>Voici une situation dans laquelle l'utilisation d'une variable avec une portée limitée présente un grand intérêt, comme dans l'extrait de code ci-dessous : l'utilisation de la variable ‘I’ à l'extérieur de la boucle provoque une erreur du compilateur (alors qu'auparavant cela provoquait simplement un avertissement) :<source lang="Delphi">
procedure ForTest;
begin
var total := 0;
for var I: Integer := 1 to 10 do
Inc (Total, I);
ShowMessage (total.ToString);
ShowMessage (I.ToString); // compiler error: Undeclared Identifier ‘I’</source>

==Variables inline répétées==

Le débogueur Delphi gère désormais les variables inline répétées portant le même nom. Pour cela, le compilateur émet des informations de portée pour chaque variable afin qu'elles soient traitées séparément.

<source lang="Delphi">
procedure Foo;
begin
if Length(Caption) < 5 then begin
var X := 5; // First ‘X’ variable
ShowMessage(IntToStr(X));
end else begin
var X := Length(Caption); // Different ‘X’ variable
ShowMessage(‘Length is:’ + IntToStr(X));
end;
end;
</source>

L'exemple de code ci-dessus montre deux blocs dans une même méthode qui possèdent chacun une variable de portée locale nommée 'X'. Le débogueur reconnaît qu'il s'agit de variables distinctes, et comme il connaît la portée de chacune, elles ne sont pas affichées en même temps.

{{Note| Les utilisateurs doivent recompiler pour obtenir ces informations dans les DCU ou les informations de débogage/packages. Les DCU sont compatibles ABI dans l'ensemble de la release 12.x Athens. Les versions 12.1 et 12.0 ne chargent pas les informations de portée.}}

[[Category:Rio]]

Options de l'EDI

Yukikoi — Fri, 09 Oct 2026 18:13:08 GMT

Yukikoi a importé Options de l'EDI par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Boîte de dialogue Options des outils}}

{{Menu|Outils > Options > EDI}}

Spécifie les préférences de la configuration de l'EDI.

==Pages enfant==

* [[Default Folders|Dossiers par défaut]]
*[[Compilation et exécution|Compilation et exécution]]
** [[Journal de construction|Journal de construction]]
* [[Barre d'outils des composants|Barre d'outils des composants]]
* [[Variables d'environnement|Variables d'environnement]]
* [[Association de fichiers|Association de fichiers]]
* [[Bureau et disposition|Bureau et disposition]]
* [[Page d'accueil|Page d'accueil]]
* [[Options relatives à l'audit de code intelligent|Audit de code intelligent]]
* [[Mise à niveau des projets|Mise à niveau des projets]]
* [[Options LiveBindings|LiveBindings]]
* [[Saving and Recovering|Enregistrement et récupération]]
* [[GetIt (Options)|Gestionnaire de packages GetIt]]

Mode Concentration

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé Mode Concentration par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Options de l'éditeur}}

{{Menu|Outils > Options > Editeur > Mode Concentration}}

Le [[Mode Concentration|mode Concentration]] est un moyen de coder sans distraction. Il vous permet de n'afficher que l'éditeur de code et cache le reste de l'interface utilisateur.

Pour activer le [[Mode Concentration|mode Concentration]], cliquez avec le bouton droit sur l'onglet et sélectionnez '''Mode Concentration''' ou utilisez le raccourci {{code|Ctrl+Alt+Z}} lorsque l'éditeur détient la focalisation. Lorsque le reste de l'interface utilisateur est caché, l'éditeur affiche le nom du fichier en haut, des boutons de fermeture, et il peut être fractionné à droite et à gauche. En [[Mode Concentration|mode Concentration]], vous devez garder à l'esprit ce qui suit :

*N'importe quel nombre d'onglets peut être ouvert dans l'éditeur en [[Mode Concentration|mode Concentration]], et plusieurs éditeurs peuvent apparaître côte à côte comme des colonnes.
*Le nombre d'éditeurs affichés côte à côte est limité par l'espace horizontal disponible. Il n'est pas possible d'ajouter une nouvelle colonne si les éditeurs redimensionnés deviennent trop petits pour travailler.
*Le glissement du séparateur vers la droite ou la gauche provoque le redimensionnement de l'éditeur par défaut tout en conservant sa position centrée.
*Des boutons sont affichés dans la partie supérieure de l'éditeur pour permettre le fractionnement de l'éditeur vers la gauche, ou la droite, et pour ouvrir une unité avec la boîte de dialogue '''Utiliser l'unité''' (vous pouvez aussi utiliser le raccourci {{code|Ctrl+F12}}). Ces options permettent de travailler sur plusieurs fichiers en [[Mode Concentration|mode Concentration]].
*Vous pouvez utiliser les couleurs de l'éditeur pour dessiner les barres de défilement.

{{Note|Dans Delphi, seuls les fichiers source de l'unité sont disponibles dans l'éditeur. Dans C++, les fichiers C++ et l'en-tête d'une unité sont disponibles dans l'éditeur. Le concepteur de fiche et d'autres vues secondaires de l'éditeur ne sont pas disponibles.}}

Lorsque l'option '''Activer le mode Concentration''' est activée, vous pouvez choisir quelles fonctionnalités vous souhaitez afficher avec votre code :

* Signets
* Marge droite
* Barre d'outils de navigation
* Pliage du code
* Infos de débogage (Points d'arrêt, lignes compilées)
* Parties modifiées
* Pas de points avec les numéros de ligne

Par défaut, le [[Mode Concentration|mode Concentration]] n'affiche que l'onglet en cours, mais l'activation de l'option '''Cloner tous les onglets en mode Concentration''' vous permet de charger toutes les vues actives.

[[File:Focus Mode.png|700px|link=]]

==Voir aussi==

* [[Options de l'éditeur|Editeur]]

Champs (Delphi)

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé Champs (Delphi) par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Classes et objets - Index}}<idetag id="var"></idetag><idetag id="Int"></idetag><idetag id="class var"></idetag><idetag id="private"></idetag><idetag id="protected"></idetag><idetag id="public"></idetag><idetag id="published"></idetag><idetag id="strict protected"></idetag>
Cette rubrique décrit la syntaxe des déclarations de champs de données des classes.

==A propos des champs==

Un champ est semblable à une variable appartenant à un objet. Les champs peuvent avoir n'importe quel type, y compris les types classe. (Les champs peuvent donc contenir des références d'objets.) Les champs sont généralement privés.

Pour définir un membre champ dans une classe, déclarez simplement le champ comme vous le feriez pour une variable. Par exemple, la déclaration suivante crée une classe appelée <span class="codeInline">TNumber</span> dont le seul membre, en dehors des méthodes héritées de [[lib_fr:System.TObject|System.TObject]], est un champ entier appelé <span class="codeInline">Int</span> :

<source lang="delphi">
type
TNumber = class
var
Int: Integer;
end;</source>

Le mot-clé '''var''' est facultatif. Toutefois, s'il n'est pas utilisé, toutes les déclarations de champs doivent être placées avant les déclarations de propriétés ou de méthodes. Après les déclarations de propriétés ou de méthodes, le mot-clé '''var''' peut être utilisé pour introduire des déclarations de champs supplémentaires.

Lorsqu'un objet est créé, ses champs sont initialisés à zéro ou aux valeurs par défaut. Ce comportement est différent de celui des variables locales qui ne sont pas initialisées. Si vous entrez :{{#tag:syntaxhighlight|
var

N: TNumber;

begin

N := TNumber.Create;

|lang=delphi}}la valeur de N.Int sera zéro.

Les champs sont liés statiquement, c'est-à-dire que les références les désignant sont réglées à la compilation. Pour comprendre ce que cela signifie, examinez le code suivant :

<source lang="delphi">
type
TAncestor = class
Value: Integer;
end;

TDescendant = class(TAncestor)
Value: string; // hides the inherited Value field
end;

var
MyObject: TAncestor;

begin
MyObject := TDescendant.Create;
MyObject.Value := 'Hello!' // error

(MyObject as TDescendant).Value := 'Hello!' // works!
end;</source>

Même si <span class="codeInline">MyObject</span> contient une instance de <span class="codeInline">TDescendant</span>, il est déclaré comme un <span class="codeInline">TAncestor</span>. Le compilateur interprète donc <span class="codeInline">MyObject.Value</span> comme une référence au champ (entier) déclaré dans <span class="codeInline">TAncestor</span>. Cependant, les deux champs existent dans l'objet <span class="codeInline">TDescendant</span> ; la valeur <span class="codeInline">Value</span> héritée est masquée par la nouvelle, mais il est possible d'y accéder en utilisant un transtypage.

Les déclarations de [[Constantes déclarées|constantes]] et de [[Constantes déclarées|constantes typées]] peuvent apparaître dans des classes et des enregistrements non anonymes avec une portée globale. Les constantes et les constantes typées peuvent également apparaître dans les définitions de [[Déclarations de types imbriqués|types imbriqués]]. Les constantes et constantes typées ne peuvent apparaître que dans les définitions de classes quand la classe est définie localement sur une procédure (c'est-à-dire qu'elles ne peuvent pas apparaître dans des enregistrements définis dans une procédure).

==Champs de classe==

Les champs de classe sont des champs de données d'une classe accessibles sans référence d'objet (à la différence des "champs d'instance" normaux qui sont traités ci-dessus). Les données stockées dans un champ de classe sont partagées par toutes les instances de la classe et peuvent être accessibles en se référant à la classe ou à une variable qui représente une instance de la classe.

La déclaration de bloc '''class var''' vous permet d'introduire un bloc de champs de classe dans une déclaration de classe. Tous les champs déclarés après '''class var''' ont des attributs de stockage statique. Un bloc '''class var''' se termine par :

# Une autre déclaration '''class var''' ou '''var'''
# Une [[Méthodes (Delphi)|déclaration de procédure ou fonction (c'est-à-dire une méthode)]] (y compris des procédures de classe et des fonctions de classe)
# Une [[Propriétés (Delphi)|déclaration de propriété]] (y compris des propriétés de classe)
# Une [[Méthodes (Delphi)|déclaration de constructeur ou de destructeur]]
# Un [[Classes et objets (Delphi)|spécificateur de portée de visibilité]] ('''public''', '''private''', '''protected''', '''published''', '''strict private''' et '''strict protected''')

Par exemple :

<source lang="delphi">
type
TMyClass = class
public
class var // Introduce a block of class static fields.
Red: Integer;
Green: Integer;
Blue: Integer;
var // Ends the class var block.
InstanceField: Integer;
end;</source>

Les champs de classe <span class="codeInline">Red</span>, <span class="codeInline">Green</span> et <span class="codeInline">Blue</span> sont accessibles par le code :

<source lang="delphi">
TMyClass.Red := 1;
TMyClass.Green := 2;
TMyClass.Blue := 3;</source>

Les champs de classe sont aussi accessibles au moyen d'une instance de la classe. Avec la déclaration suivante :

<source lang="delphi">
var
myObject: TMyClass;</source>

Ce code a le même effet que les assignations de <span class="codeInline">Red</span>, <span class="codeInline">Green</span> et <span class="codeInline">Blue</span> ci-dessus :

<source lang="delphi">
myObject.Red := 1;
myObject.Green := 2;
myObject.Blue := 3;</source>

==Voir aussi==

*[[Variables (Delphi)|Variables ({{Delphi}})]]
*[[Classes et objets (Delphi)|Classes et objets (Delphi)]]
*[[Méthodes (Delphi)|Méthodes (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)]]

[[Category:Delphi]]
[[Category:Guide du langage Delphi]]
[[Category:AMMigrate]]

Delphi RTTI et C++Builder

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé Delphi RTTI et C++Builder par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Utilisation des informations RTTI - Index|Utilisation des informations RTTI}}

==Découverte du type à l'exécution (réflexion)==

===Désambiguïsation===

Les informations RTTI de {{Delphi}} sont différentes des informations RTTI standard de C++ :

*Les informations RTTI de {{Delphi}} vous permettent d'explorer les champs, les méthodes d'une classe, et ainsi de suite.
*Les informations RTTI de C++ vous permettent d'identifier le type d'une variable et de comparer l'égalité des types, ou l'ordre de tri.

{{Note| L'option du compilateur {{Menu|Projet > Options > [[Compilateur C++|Compilateur C++]] > Activer la RTTI'''}} fait référence à une RTTI C++ standard.}}'''

===Génération des informations RTTI===

Seules les classes de style {{Delphi}} peuvent avoir des informations de style {{Delphi}} dans C++ (voir [[Declspec(delphiclass)|__declspec(delphiclass)]]).

Des informations RTTI peuvent être générées pour tout type de membre de classe (méthodes, champs, propriétés) avec toute visibilité (__published, public, protected, private). Pour contrôler la génération des informations RTTI, les spécifications suivantes peuvent être utilisées :

*[[Pragma explicit rtti|#pragma explicit_rtti]] (c'est l'équivalent C++ de [[Directive RTTI (Delphi)|<nowiki>{$RTTI}</nowiki>]])
*[[Declspec(delphirtti)|__declspec(delphirtti)]] (c'est l'équivalent C++ de [[Informations de type à l'exécution (Delphi)|<nowiki>{$M}/{$TYPEINFO}</nowiki>]])
*[[Published|__published]]

'''Exemple :'''<source lang="cpp">
#include <System.hpp>
#include <Rtti.hpp>
#include <tchar.h>
#include <stdio.h>

// Enable RTTI generation for private fields
#pragma explicit_rtti fields(private)

class __declspec(delphiclass) TBuffer {
private:
int wrHead, rdHead;

// ...
public:
TBuffer() {

}
};

// ---------------------------------------------------------------------------

int _tmain(int argc, _TCHAR* argv[]) {
TRttiContext context;

// Get class RTTI
TRttiInstanceType *cls = dynamic_cast<TRttiInstanceType*>
(context.GetType(__delphirtti(TBuffer)));

if (cls) {
// Get field RTTI
TRttiField *field = cls->GetField("wrHead");
if (field) {
printf("%ls", field->ToString().c_str());
}
else {
puts("\"wrHead\" doesn't have RTTI");
}
}
else {
puts("\"TBuffer\" doesn't have RTTI");
}

return 0;
}</source>

'''Sortie console :'''

wrHead: int @ 00

Dans cet exemple, les informations RTTI de classe sont extraites à l'aide de la fonction [[Delphirtti|__delphirtti]] (qui renvoie un pointeur sur une variable [[lib_fr:System.TypInfo.TTypeInfo|TTypeInfo]]). Il est possible de faire la même chose avec l'opérateur [[Classid|__classid]]. Voir le code suivant<source lang="cpp">
TRttiInstanceType *cls = dynamic_cast<TRttiInstanceType*>
(context.GetType(__classid(TBuffer)));</source>Sur la plate-forme Windows, le [[Delphirtti|__delphirtti]] d'un [[Wchar t|wchar_t]] renvoie un [[lib_fr:System.TypInfo.PTypeInfo|PTypeInfo]] qui correspond à la RTTI {{Delphi}} pour le {{Delphi}} [[lib_fr:System.WideChar|WideChar]].

Cette fonctionnalité est illustrée dans l'exemple de code suivant :

<source lang="cpp">
#include <stdio.h>

static System::UTF8String getTypeInfoName(System::Typinfo::PTypeInfo ti)
{
#ifndef _DELPHI_NEXTGEN
return System::UTF8String(ti->Name);
#else
int len = ti->Name;
const char* p = reinterpret_cast<char*>(&(ti->Name));
return System::UTF8String(p+1, len);
#endif
}

int main()
{
System::Typinfo::PTypeInfo pti;
pti = __delphirtti(char16_t);
printf("Kind=%d, Name='%s'\n", pti->Kind, getTypeInfoName(pti).c_str());
pti = __delphirtti(wchar_t);
printf("Kind=%d, Name='%s'\n", pti->Kind, getTypeInfoName(pti).c_str());
return 0;
}</source>

'''Sortie :'''

{| border="1" frame="hsides" rules="rows"
|-
!'''Plate-forme'''
!'''Sortie'''
|-
| style="text-align: left; vertical-align: top;" |
WIN64
| style="text-align: left; vertical-align: top;" |
Kind=1, Name='char16_t'{{#tag:br|}}
Kind=9, Name='Char'
|}

===Enracinement du type===

Vous ne pouvez pas utiliser les méthodes [[lib_fr:System.Rtti.TRttiContext.FindType|FindType]] et [[lib_fr:System.Rtti.TRttiContext.GetTypes|GetTypes]] pour obtenir la RTTI {{Delphi}} pour les classes définies en langage C++ car [[lib_fr:System.Rtti.TRttiContext.FindType|FindType]] et [[lib_fr:System.Rtti.TRttiContext.GetTypes|GetTypes]] effectuent des recherches dans les packages d'exécution. Or, il n'existe pas d'enracinement de type dans les packages C++. Cela signifie que vous ne pourrez pas utiliser [[lib_fr:System.Rtti.TRttiPackage|TRttiPackage]] pour obtenir des informations sur un package dynamique construit avec C++Builder.

En revanche, le lieur {{Delphi}} enracine la RTTI dans les [[lib_fr:System.PackageInfoTable|tables d'informations des packages]]. En conséquence, en C++, vous pouvez charger et utiliser la RTTI de style {{Delphi}} depuis des modules {{Delphi}} (packages), comme dans le code suivant :

<source lang="cpp">
TRttiContext context;
TRttiType *rttiType = context.FindType("Classes.TStringList");
printf("%ls", rttiType->ToString()); // displays TStringList</source>

==Attributs==

Les attributs {{Delphi}} ne sont pas pris en charge dans {{CBuilder}}. {{CBuilder}} prend en charge les '''[[Fonctionnalités C++11 - Index|attributs de C++11]]''', qui sont différents des attributs {{Delphi}} :

*Les attributs {{Delphi}} représentent des informations supplémentaires pour le programmeur et ils peuvent être extraits à l'exécution.
*Les attributs C++11 représentent des informations supplémentaires pour le compilateur et ne sont pas spécifiques à RTTI.

==Voir aussi==

===Informations RTTI de {{Delphi}}===

*[[lib_fr:System.Rtti|API RTTI]]
*[[Utilisation des informations RTTI - Index|Utilisation des informations RTTI]]
*[[Présentation des attributs|Attributs et RTTI]]

===Informations RTTI de {{Delphi}} dans {{CBuilder}}===

*[[Declspec(delphirtti)|__declspec(delphirtti)]]

===Informations RTTI de C++===

*[[Identification de type à l'exécution (RTTI) - Index|Identification de type à l'exécution (RTTI) - Index]]
*[[Typeid|typeid]] (mot clé)
*[[Rtti et option -RT|__rtti et option -RT]]

[[Category:Référence C++]]
[[Category:C++]]
[[Category:RTTI]]

Compilateur Delphi

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé Compilateur Delphi par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Construction}}

{{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}

__TOC__
Utilisez cette page pour définir les options du compilateur {{Delphi}} pour le projet en cours.

[[File:Delphi Compiler options.jpg|=link]]

{{Note|Les options décrites ici ne sont pas toutes disponibles pour tous les types de projets. Par exemple, '''Répertoire de sortie DCP''' n'apparaît pas pour les projets C++.}}

{| border="1" frame="hsides" rules="rows"
|-
!'''Options'''
!'''Description'''
|- valign="top"
|
Cible, Appliquer, Enregistrer
|
Voir [[Options de la cible|Options de la cible]].
|- valign="top"
|
Eléments communs
|
Voir [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]].
|}

{| border="1" frame="hsides" rules="rows"
|-
!Elément
!Description
! style="padding-left: 5px; padding-right: 5px;" |Commutateurs du compilateur
! style="padding-left: 5px; padding-right: 5px;" |[[Plates-formes cible prises en charge|Toutes les plates-formes]] sont prises en charge sauf spécification contraire
|- valign="top"
|
Définitions conditionnelles
|
Spécifie les symboles référencés dans vos directives de compilation conditionnelles. Utilisez un point-virgule pour séparer plusieurs symboles. Par exemple, tapez : <code>DEBUG;Platform32Bit</code>.
Cliquez sur les [[Image:ProjectOptionsEllipsis.jpg|points de suspension]] pour ouvrir la boîte de dialogue '''[[Boîte de dialogue liste-ordonnée|Définitions conditionnelles]]'''.
| style="vertical-align: middle; text-align: center;" |
<code>-D</code>
|
|- valign="top"
|
Répertoire de sortie DCP
|
Spécifie où le [[Fichier package compilé Delphi (*.dcp)|fichier de package compilé]] ({{Path|.dcp}}) est placé lors de la compilation. Si le champ est vide, le '''répertoire de sortie DCP''' global spécifié dans la page {{menu|Outils > Options > Options d'environnement > Options {{Delphi}} > Bibliothèque}} sera utilisé à la place.
Le bouton popup [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]] ouvre une [[Boîte de dialogue liste-ordonnée|boîte de dialogue <liste-ordonnée>]] pour la sélection et l'ajout de répertoires, comme décrit dans [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]].
| style="vertical-align: middle; text-align: center;" |
<code>-LN</code>
|
|- valign="top"
|
Chemin de recherche du framework
|
Spécifie les chemins de recherche dans lesquels le compilateur recherche les frameworks.
Séparez les alias par un point-virgule.
| style="vertical-align: middle; text-align: center;" |
<code>‑‑frameworkpath</code>
|
Périphérique iOS  (64 bits)
|- valign="top"
|
Répertoire de sortie
|
Spécifie l'endroit où le compilateur doit placer le fichier exécutable. Le bouton popup [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]] ouvre une [[Boîte de dialogue liste-ordonnée|boîte de dialogue <liste-ordonnée>]] pour la sélection et l'ajout de répertoires, comme décrit dans [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]].
| style="vertical-align: middle; text-align: center;" |
<code>-E</code>
|
|- valign="top"
|
Répertoire de sortie des packages
|
Spécifie le répertoire où le compilateur place les fichiers de packages générés. Le bouton popup [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]] ouvre une [[Boîte de dialogue liste-ordonnée|boîte de dialogue <liste-ordonnée>]] pour la sélection et l'ajout de répertoires, comme décrit dans [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]].
Cette option détermine le répertoire de sortie des fichiers suivants :
*[[Fichier manifest d'application Android (AndroidManifest.xml)|Fichier manifest d'application Android (AndroidManifest.xml)]]
*[[Fichier des droits d'application Apple (*.entitlements)|Fichier des droits d'application Apple (*.entitlements)]]
*[[Fichier des informations d'application Apple (*.info.plist)|Fichier des informations d'application Apple (*.info.plist)]]
*[[Fichier des règles de ressources d'application Apple|Fichier des règles de ressources d'application Apple (ResourceRules.plist)]]
*[[Fichier de chaînes de ressources Delphi (*.drc)|Fichier de chaînes de ressources Delphi (*.drc)]]
*[[Map Debug File|Fichier de débogage map]]
*[[Fichier de bibliothèque partagée de package|Fichier de bibliothèque dynamique de package]]
*[[Fichier de débogage RSM|Fichier de débogage RSM]]
*[[Fichier de débogage TDS|Fichier de débogage TDS]]
| style="vertical-align: middle; text-align: center;" |
<code>-LE</code>
|
|- valign="top"
|
Chemin de recherche
|
Spécifie l'emplacement de vos fichiers source. Seuls les fichiers qui se trouvent sur le chemin de recherche du compilateur ou sur le chemin de recherche des bibliothèques sont inclus dans la construction. Si vous essayez de construire votre projet avec un fichier absent du chemin de recherche, vous recevrez une erreur de compilation. Vous devez inclure le chemin de recherche complet.
Séparez plusieurs noms de répertoires en les séparant par un point-virgule. Les espaces avant ou après le point-virgule sont autorisés mais pas nécessaires. Les chemins relatifs et absolus sont autorisés, notamment les chemins relatifs à la position en cours.
| style="vertical-align: middle; text-align: center;" |
<code>-U</code>
|
|- valign="top"
|
Afficher les messages généraux
|
Définissez cette option to {{Code|True}} afin d'afficher les messages d'information du compilateur dans l'onglet de sortie [[Vue Messages|Vue Messages]].
|
|
|- valign="top"
|
Chemin racine de bibliothèque système
|
Spécifie les chemins racine dans lesquels le compilateur recherche les bibliothèques système.
Séparez les alias par un point-virgule.
| style="vertical-align: middle; text-align: center;" |
<code>‑‑syslibroot</code>
|
Périphérique iOS  (64 bits)
|- valign="top"
|
Alias d'unités
|
Utile pour la compatibilité ascendante. Spécifiez les noms d'alias pour les unités dont le nom a été modifié ou qui ont été fusionnées au sein d'une unité unique. Le format est
<oldunit>=<newunit>
Par exemple :
Forms=Xforms
Séparez les alias par un point-virgule. La valeur par défaut pour {{Delphi}} est <code>WinTypes=Windows;WinProcs=Windows.Default</code>. Le bouton popup [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]] ouvre une [[Boîte de dialogue liste-ordonnée|boîte de dialogue <liste-ordonnée>]] pour la sélection et l'ajout de répertoires, comme décrit dans [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]].
| style="vertical-align: middle; text-align: center;" |
<code>-A</code>
|
|- valign="top"
|
Répertoire de sortie des unités
|
Spécifie un répertoire distinct pour contenir les [[Fichier unité compilé Delphi (*.dcu)|unités compilées]] ({{Path|.dcu}}). Cliquez sur [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]] pour ouvrir la boîte de dialogue '''Rechercher un dossier'''.
| style="vertical-align: middle; text-align: center;" |
<code>-NU</code>
|
|- valign="top"
|
Noms de portées d'unités
|
Spécifie les [[Noms de portées d'unités|noms de portées d'unités]] (préfixes) pour les espaces de nommage {{Delphi}} à points, afin de vous permettre d'utiliser partiellement les noms qualifiés dans votre code, et dans votre clause <code>uses</code> ou <code>#include</code>.
Il existe deux façons d'ajouter un nom de portée d'unité pour une unité {{Delphi}} :
*Spécifiez le nom de portée d'unité complet dans votre clause <code>uses</code>. Par exemple :
**<code> uses FMX.Graphics;</code> ({{Delphi}})
*Ajoutez le nom de portée d'unité (<code>FMX</code>) au champ '''Noms de portées d'unités'''. Le nom de portée d'unité <code>FMX</code> est alors appliqué automatiquement aux noms d'unités qui appartiennent à cette portée d'unité, et vous pouvez simplement spécifier :
**<code>uses Graphics;</code> ({{Delphi}})

Le bouton popup [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]] ouvre une [[Boîte de dialogue liste-ordonnée|boîte de dialogue <liste-ordonnée>]] pour la sélection et l'ajout de noms de portée d'unité, comme décrit dans [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]] et [[Boîte de dialogue liste-ordonnée|Boîte de dialogue liste ordonnée]].
| style="vertical-align: middle; text-align: center;" |
<code>-NS</code>|
|
|- valign="top" {{fr|radstudio}}
|
Utiliser MSBuild de façon externe pour compiler
|
Si cette option est activée, votre projet est construit à l'extérieur de l'EDI en utilisant [[MSBuild|MSBuild]].
Vous pouvez utiliser cette option si {{Product}} [[F2046 Mémoire insuffisante (Delphi)|est à cours de mémoire lorsque vous construisez votre groupe de projet]].
Vous devez :
*Enregistrer votre projet avant de tenter d'effectuer une construction lorsque vous utilisez cette option.
*Activez l'option '''Symboles de débogage distant''' sur la page [[Liaison (Delphi)|Liaison]] si vous voulez utiliser le débogueur intégré avec votre projet MSBuild.

Valeur par défaut = False
{{Note|Utilisez cette option pour empêcher les problèmes qui surviennent lorsque la ligne de commande vers DCC32 dépasse 3200 octets. Lorsque cette option est activée, le script MSBuild génère automatiquement un fichier de réponse <code><votre projet>.cmds</code> qui est transmis à DCC32.}}
{| border="1" frame="hsides" rules="rows"
|- valign="top"
|
Architecture d'outil préférée
|
Lorsque vous compilez avec MSBuild, spécifiez la version de vos outils préférés à utiliser.
Utilisez la propriété {{code|DCC_PreferredToolArchitecture}} pour contrôler quelle architecture binaire doit être utilisée pour les compilateurs Delphi.
Pour bin\DCC32 ou bin\DCC64, utilisez :
/p:DCC_PreferredToolArchitecture=x32
Et pour bin64\DCC32 ou bin64\DCC64, utilisez :
/p:DCC_PreferredToolArchitecture=x64
L'utilisation des outils 64 bits permet de bénéficier d'un plus grand espace mémoire pour le compilateur.
{{Note|L'option d'architecture des outils 64 bits est uniquement disponible pour les plates-formes suivantes :
*Compilateurs cibles Delphi Windows 32 bits
*Compilateurs cibles Delphi Windows 64 bits}}
|}
| style="vertical-align: middle; text-align: center;" |
|
|}

==Conseils==

*Pour afficher les options du compilateur dans la fenêtre '''Messages''' quand vous compilez un projet, choisissez <font color="#598527"> '''Outils > Options > Options d'environnement''' </font> et sélectionnez '''Afficher la ligne de commande'''. Lors de la prochaine compilation d'un projet, la commande utilisée pour compiler le projet et le fichier de réponse seront tous deux affichés dans la fenêtre '''Messages'''. Le fichier de réponse liste les options du compilateur et les fichiers à compiler.<br />
*Pour afficher plusieurs valeurs dans une zone d'édition, séparez-les par un point-virgule. Vous pouvez aussi cliquer sur le bouton points de suspension placé à côté de chaque zone d'édition pour ajouter plusieurs valeurs par l'intermédiaire d'une boîte de dialogue appropriée.<br />
*Pour spécifier des [[Variables d'environnement|variables d'environnement]] du système d'exploitation ou des variables d'environnement définies dans l'EDI dans une zone d'édition, utilisez la syntaxe suivante : <code>$(NomVariable)</code>.
*:Par exemple, la variable '''$(Config)''' est résolue sur la configuration spécifique qui est définie dans le [[Options de la cible|champ Cible]] de la page Options de projet spécifique où '''$(Config)''' est spécifiée. Si vous spécifiez $(Config) dans un chemin, puis construisez avec une configuration '''Débogage''' en tant que '''cible''', $(Config) inclut seulement le répertoire '''Débogage''' et des éléments existant seulement dans le répertoire '''Release''' peuvent être absents de la construction.

==Pages enfant==

*[[Compilation|Compilation]]
*[[Conseils et avertissements|Conseils et avertissements]]
*[[Liaison (Delphi)|Liaison]]
*[[Sortie - C/C++|Sortie - C/C++]]
*[[Prise en charge de l'assembleur intégré pour AVX2 et AVX-512|Prise en charge de l'assembleur intégré pour AVX2 et AVX-512]]

==Voir aussi==

*[[DCC32.EXE, le compilateur en ligne de commande Delphi|DCC32.EXE, le compilateur en ligne de commande Delphi]]
*[[DCC64.EXE, le compilateur en ligne de commande Delphi 64 bits|DCC64.EXE, le compilateur en ligne de commande Delphi 64 bits]]
*[[DCCOSX64.EXE, le compilateur Delphi pour macOS 64 bits|DCCOSX64.EXE, le compilateur Delphi pour macOS 64 bits]]
*[[DCCAARM.EXE, le compilateur Delphi pour Android|DCCAARM.EXE, le compilateur Delphi pour Android]]
*[[DCCAARM64.EXE, le compilateur Delphi pour Android 64 bits|DCCAARM.EXE, le compilateur Delphi pour Android 64 bits]]
*[[DCCIOSARM64.EXE, le compilateur Delphi pour le périphérique iOS 64 bits|DCCIOSARM64.EXE, le compilateur Delphi pour le périphérique iOS 64 bits]]
*[[DCCLINUX64.EXE, le compilateur Delphi pour Linux|DCCLINUX64.EXE, le compilateur Delphi pour Linux]]
*[[Compilation, construction et exécution d'applications|Compilation, construction et exécution d'applications]]
*[[Création et modification de configurations de construction|Création et modification de configurations de construction]]
*[[Compilation et construction des applications multi-périphériques|Compilation et construction des applications multi-périphériques]]
*[[Ajout de noms de portées d'unités pour vos propres composants|Ajout de noms de portées d'unités pour vos propres composants]]
*[[Bibliothèque|Bibliothèque]]

[[Category:Référence RAD Studio]]
[[Category:AMMigrate]]

Raccourcis clavier par défaut

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé Raccourcis clavier par défaut par téléversement de fichier (1 version) LOC-23451

Voir les modifications

DCCLINUX64.EXE, le compilateur Delphi pour Linux

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé DCCLINUX64.EXE, le compilateur Delphi pour Linux par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Interfaces de ligne de commande des compilateurs Delphi basés sur LLVM}}
{{DISPLAYTITLE: DCCLINUX64.EXE, le compilateur Delphi pour Linux 64 bits Intel}}<code>DCCLINUX64.EXE</code> est l'interface de ligne de commande de [[DCCLINUX64|DCCLINUX64]], le compilateur Delphi pour Linux 64 bits Intel.

Voir '''[[Interfaces de ligne de commande des compilateurs Delphi basés sur LLVM|Interfaces de ligne de commande des compilateurs {{Delphi}} basés sur LLVM]]''' pour savoir ce que l'interface de ligne de commande {{Path|DCCLINUX64}} a en commun avec les autres interfaces de ligne de commande des compilateurs {{Delphi}} basés sur LLVM.

{{Note|La fonctionnalité des binaires 64 bits est limitée aux versions supérieures. Elle est disponible dans les éditions Enterprise et Architect, mais pas dans les éditions Professional ou CE.}}

==Voir aussi==

*[[DCCLINUX64|DCCLINUX64]]
*[[DCCAARM|DCCAARM]]
*[[Développement d'applications mobiles Android|Développement d'applications mobiles Android]]
*[[Périphériques Android pris en charge pour le développement d'applications|Périphériques Android pris en charge pour le développement d'applications]]
*[[Migration du code Delphi en mobile depuis le bureau|Migration du code Delphi en mobile depuis le bureau]]

Documentation des API personnalisées

Yukikoi — Fri, 09 Oct 2026 18:13:07 GMT

Yukikoi a importé Documentation des API personnalisées par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Extension du moteur RAD Server}}

{{Product}} vous permet de créer une documentation API pour de nouveaux modules de ressources RAD Server aux formats YAML et JSON. La nouvelle implémentation est basée sur la spécification de [http://swagger-api.github.io/swagger-core/spec.html documentation API Swagger RESTful].

'''EMS.ResourceType''' implémente les nouveaux attributs pouvant être utilisés pour générer la documentation API des points de terminaison d'une ressource.

==EndPointRequestSummary==

Description d'une méthode :

<source lang="Delphi">
[EndPointRequestSummary('ATags', 'ASummary', 'ADescription', 'AProduces', 'AConsume')]</source>

*'''Tags''' : définit une balise.
*'''Summary''' : titre d'une méthode.
*'''Description''' : description d'une méthode.
*'''Produces''' : type MIME que l'API peut produire. Global pour toutes les API, mais peut être redéfini sur des appels d'API spécifiques. La valeur doit être décrite sous Mime Types.
*'''Consume''' : type MIME que l'API peut consommer. Global pour toutes les API, mais peut être redéfini sur des appels d'API spécifiques. La valeur doit être décrite sous Mime Types.

Exemple de déclaration de la description de la méthode GET d'un point de terminaison :

<source lang="Delphi">
[EndPointRequestSummary('Api Doc', 'Get API EndPoints', 'Used to retrieve all the API EndPoints', 'application/json', '')]
procedure Get(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);</source>

==EndPointRequestParameter==

Description des paramètres utilisés dans une requête.

Un paramètre unique est défini par la combinaison d'un nom et d'un emplacement.

Il existe cinq types de paramètres possibles : Path, Query, Header, Body et Form.

<source lang="Delphi">
[EndPointRequestParameter('AIn', 'AName', 'ADescription', 'ARequired', 'AType', 'AFormat', 'AItemType', 'AJSONSchema', 'AReference')]</source>

*'''ParamIn''' : l'emplacement du paramètre : Path, Query, Header, Body ou Form.
*'''Name''' : le nom du paramètre. Les noms de paramètres sont sensibles à la casse.
**Quand l'emplacement du paramètre est 'Body', son nom doit être 'body'.
**Quand l'emplacement du paramètre est 'Path', son nom doit correspondre au segment de chemin d'accès associé depuis le champ chemin dans l'objet Paths.
**Dans les autres cas, son nom correspond à ParamIn.
*'''Description''' : brève description du paramètre. Elle peut contenir des exemples d'utilisation. Vous pouvez utiliser la syntaxe GFM pour une représentation de texte formaté.
*'''Required''' : détermine si le paramètre est obligatoire. Si le paramètre est dans 'Path', cette propriété est requise et sa valeur doit être '''True''', sinon la propriété peut être incluse et sa valeur par défaut est '''False'''.
*'''ParamType''' : le type du paramètre. Pour des valeurs autres que 'Body', la valeur doit être l'une des valeurs suivantes : 'spArray', 'spBoolean', 'spInteger', 'spNumber', 'spNull', 'spObject', 'spString', 'spFile'. Si ParamType vaut 'spFile', le type MIME consommé doit être soit "multipart/form-data", soit "application/x-www-form-urlencoded" et le paramètre doit être de "form-data". Pour la valeur 'Body', JSONSchema et Reference sont requis.
*'''ItemFormat''' : le format d'extension pour le ParamType : 'None', 'Int32', 'Int64', 'Float', 'Double', 'Byte', 'Date', 'DateTime', 'Password'.
*'''ItemType''' : requis si ParamType a la valeur 'array'. Décrit le type des éléments dans le tableau.
*'''JSONSchema''' : la définition de schéma de la primitive envoyée au serveur. Il s'agit d'une définition de la structure de la requête du corps. Si ParamType vaut 'Array' ou 'Object', un schéma peut être défini.
**Par exemple :
**:<nowiki>Au format JSON : {"type": "object","additionalProperties": {"type": "string"}}.</nowiki>
**:Au format YAML :
**::type: object
**::additionalProperties:
**::type: string
*'''Reference''' : La définition de schéma de la primitive envoyée au serveur. Il s'agit d'une définition de la structure de la requête du corps. Si Type vaut 'Array' ou 'Object', un schéma peut être défini.
**Par exemple :
**:'#/definitions/pet'

<source lang="Delphi">
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Path, 'item', 'Path Parameter item Description', true, TAPIDoc.TPrimitiveType.spString, TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]</source>

==EndPointResponseDetails==

Description des réponses à la requête :

<source lang="Delphi">
[EndPointResponseDetails('ACode', 'ADescription', 'AType', 'AFormat', 'ASchema', 'AReference')]</source>

*'''Code''' : le code de réponse.
*'''Description''' : description du code de réponse.
* '''PrimitiveType''' : le type de la [http://swagger-api.github.io/swagger-core/spec.html#4-3-1-primitives Primitive] renvoyée. Les types de données primitifs compris dans la spécification Swagger sont basés sur les types pris en charge par le JSON-Schema Draft 4. JSON Schema définit sept types primitifs pour des valeurs JSON : 'spArray', 'spBoolean', 'spInteger', 'spNumber', 'spNull', 'spObject', 'spString'. Voir [https://json-schema.org/draft/2020-12/json-schema-core JSON Schema primitive types (EN)]. Un type de données primitif supplémentaire, 'spFile', est utilisé par Parameter Object et Response Object pour définir le type de paramètre ou la réponse comme étant un fichier.
*'''PrimitiveFormat''' : le format de la primitive renvoyée, par exemple : 'None', 'Int32', 'Int64', 'Float', 'Double', 'Byte', 'Date', 'DateTime', 'Password'.
*'''Schema''' :
**Par exemple :
**:<nowiki>Au format JSON : {"type": "object","additionalProperties": {"type": "string"}}.</nowiki>
**:Au format YAML :
**::type: object
**::additionalProperties:
**::type: string
*'''Reference :''' la définition de schéma de la primitive renvoyée. Il s'agit d'une définition de la structure de la réponse. Si PrimitiveType vaut 'spArray' ou 'spObject', une définition de schéma peut être définie.
**Par exemple :
**:'#/definitions/pet'

<source lang="Delphi">
[EndPointResponseDetails(200, 'Ok', TAPIDoc.TPrimitiveType.spObject, TAPIDoc.TPrimitiveFormat.None, '', '#/definitions/EmployeeTable')]
[EndPointResponseDetails(404, 'Not Found', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]</source>

==EndPointObjectsYAMLDefinitions==

Définition des objets pour la version YAML de l'API.

<source lang="Delphi">
[EndPointObjectsYAMLDefinitions(Objects)]</source>

*Objects : définitions d'objets YAML.

<source lang="Delphi" start="1">
type
[ResourceName('SampleAttributes')]
[EndPointObjectsYAMLDefinitions(cYamlDefinitions)]

// YAML Object definition:
cYamlDefinitions = '''
#
PutObject:
properties:
EMP_NO:
type: integer
FIRST_NAME:
type: string
LAST_NAME:
type: string
PHONE_EXT:
type: string
HIRE_DATE:
type: string
format: date-time
DEPT_NO:
type: string
JOB_CODE:
type: string
JOB_GRADE:
type: integer
JOB_COUNTRY:
type: string
SALARY:
type: integer
FULL_NAME:
type: string
#
...</source>

{{Note|Si la définition YAML est omise et que la définition JSON est fournie, la définition JSON sera automatiquement convertie au format YAML.}}

==EndPointObjectsJSONDefinitions==

Définition des objets pour la version JSON de l'API.

<source lang="Delphi">
[EndPointObjectsJSONDefinitions(Objects)]</source>

*Objects : définitions d'objets JSON.

<source lang="Delphi">
type
[ResourceName('SampleAttributes')]
[EndPointObjectsJSONDefinitions(cJSONDefinitions)]

// JSON Object definition:

cJSONDefinitions = '''
{
"PutObject": {
"properties": {
"EMP_NO": {
"type": "integer"
},
"FIRST_NAME": {
"type": "string"
},
"LAST_NAME": {
"type": "string"
},
"PHONE_EXT": {
"type": "string"
},
"HIRE_DATE": {
"type": "string",
"format": "date-time"
},
"DEPT_NO": {
"type": "string"
},
"JOB_CODE": {
"type": "string"
},
"JOB_GRADE": {
"type": "integer"
},
"JOB_COUNTRY": {
"type": "string"
},
"SALARY": {
"type": "integer"
},
"FULL_NAME": {
"type": "string"
}
}
}
'''</source>{{Note|Si la définition JSON est omise et que la définition YAML est fournie, la définition YAML sera automatiquement convertie au format JSON.}}

==Rubriques==

* [[Création d'un package RAD Server|Création d'un package RAD Server]]
* [[Ajout d'un module RAD Server à un package RAD Server|Ajout d'un module RAD Server à un package RAD Server]]
* [[Installation d'un package RAD Server|Installation d'un package RAD Server]]

==Voir aussi==

*[[samp_en:EMS.APIDocAttributes Sample|Exemple API Documentation Attributes]]
* [[Ressources API de RAD Server|Ressources API de RAD Server]]
*[http://swagger-api.github.io/swagger-core/spec.html Swagger RESTful API Documentation Specification (EN)]
* [[Moteur RAD Server (Serveur EMS)|Moteur RAD Server (serveur EMS)]]
* [[Console de RAD Server|Console RAD Server]]
* [[Application client de RAD Server|Application client RAD Server]]

[[Category:Berlin]]

Configuration d'Ollama pour l'audit de code intelligent

Yukikoi — Fri, 09 Oct 2026 18:13:04 GMT

Yukikoi a importé Configuration d'Ollama pour l'audit de code intelligent par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Audit de code intelligent}}

{{Product}} prévoit de fournir dans les prochaines versions une ou plusieurs images Docker préconfigurées d'Ollama avec CodeLlama afin de faciliter la configuration et l'intégration. En attendant, vous pouvez suivre les [https://ollama.com/ étapes recommandées].

{{Note| Une image Docker Ollama peut être installée sur un serveur Linux dédié et le sous-système Windows Linux (WLS). Pour simplifier la configuration, vous pouvez envisager d'utiliser Docker Desktop. Cet outil est gratuit sous réserve de l'acceptation du contrat de licence du produit. Les grandes entreprises doivent payer une licence. Pour plus d'informations, consultez [https://www.docker.com/products/docker-desktop/ cette page].}}

{{Note| Pour les images Nvidia-GPU ou AMD-GPU, consultez les instructions [https://hub.docker.com/r/ollama/ollama de cette page].}}

Vous trouverez ci-dessous un guide simplifié pour installer, exécuter et utiliser Ollama. Veuillez suivre les étapes ci-dessous.

==Vérification de votre installation Docker==

Vérifiez que Docker est bien installé comme indiqué ci-dessous.

===Docker Desktop sur Windows===

<ol><li> Vérifiez que Docker Desktop est bien installé en lançant une recherche depuis le '''menu Démarrer'''.</li>
<li> Vérifiez l'état du Docker Engine en l'ouvrant.</li>
<li> Vérifiez '''Docker Desktop Engine''' en utilisant la commande PowerShell suivante :<source>docker --version</source></li>
</ol>

===Docker sur WSL2===

<ol><li> Ouvrez un terminal WSL2.</li>
<li> Exécutez la commande suivante.<source>docker --version</source></li>
<li> Vérifiez l'état du Docker Engine en exécutant :<source>sudo service docker status</source>{{Attention|Les données en sortie doivent indiquer que Docker est actif (en cours d'exécution).}}</li>
<li>Si Docker n'est pas exécuté, vous pouvez le démarrer en exécutant la commande suivante :<source>sudo service docker start</source></li>
</ol>

==Exécution et utilisation d'Ollama==

<ol><li>[[Configuration d'Ollama pour l'audit de code intelligent#Vérification de votre installation Docker|Vérifiez que Docker est bien installé]] et que le Docker Engine est exécuté.</li>
<li>Ouvrez PowerShell ou CMD et exécutez la commande suivante<source>docker login</source></li>
<li>Connectez-vous avec le nom d'utilisateur et le mot de passe de votre Docker Hub.</li>
<li>Installez et exécutez l'image Embarcadero :<source>docker run --name Embarcadero_Codellama -p 11434:11434 radstudio/codellama:latest</source>

{{Note|Veuillez prendre en compte les informations suivantes lors des étapes ci-dessous :<ul><li><code>-name</code> est incorrect, mais <code>--name</code> est correct (vous devez saisir les deux traits).</li>
<li>Vous pouvez [https://docs.docker.com/reference/cli/docker/container/rename/ renommer le conteneur], mais si vous changez 'Embarcadero_Codellama', vous devez reporter la modification dans les autres commandes.</li>
<li>Vous pouvez utiliser n'importe quel autre numéro de port en respectant le format '''‘-p 12345:54321’'''<ul><li>'''Chiffre de gauche (12345)''' : c'est le port de l'hôte. Il correspond au port de votre machine locale (la machine sur laquelle Docker est exécutée) que vous souhaitez lier au conteneur.</li>
<li>'''Chiffre de droite (54321)''' : c'est le port du conteneur. Il correspond au port à l'intérieur du conteneur Docker que votre application utilise pour écouter. </li>
</ul>
</li>
</ul>

}}

</li>
<li>Testez Ollama en utilisant la ligne de commande (étape facultative)<source>docker exec -it Embarcadero_Codellama ollama run codellama</source><ol><li>Posez une question et vérifiez la réponse.</li>
<li>Quittez le mode Chat avec Ctrl + D ou /bye.</li>
<li>Vous pouvez maintenant fermer la ligne de commande</li>
</ol>
</li>
<li>Depuis la page Options de l'EDI, utilisez les informations de connexion suivantes :<ul><li>'''URL''': [http://localhost:11434/api/generate http://localhost:11434/api/generate]</li>
<li>'''Model''' : codellama</li>
</ul>
</li>
</ol>

Interfaces de ligne de commande des compilateurs C++ améliorés par Clang

Yukikoi — Fri, 09 Oct 2026 18:13:04 GMT

Yukikoi a importé Interfaces de ligne de commande des compilateurs C++ améliorés par Clang par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Interfaces de ligne de commande des compilateurs C++}}

Les interfaces de ligne de commande des [[Compilateurs C++ améliorés par Clang|compilateurs C++ améliorés par Clang]] sont très similaires les unes aux autres. Cette rubrique fournit les informations qui s'appliquent à toutes les interfaces.

==Options de ligne de commande des compilateurs C++ améliorés par Clang==

{{Note|L'utilisation des compilateurs C++ basés sur Clang sur la ligne de commande peut produire des résultats inattendus. Toutefois, les options des compilateurs C++ basés sur Clang disponibles dans l'EDI ont été testées lors de l'implémentation. Pour de plus amples informations, voir :

:
:*[[Options de projet prises en charge par les compilateurs C++ améliorés par Clang|Options de projet prises en charge par les compilateurs C++ améliorés par Clang]]
:*[[Options non prises en charge par les compilateurs C++ améliorés par Clang|Options non prises en charge par les compilateurs C++ améliorés par Clang]]}}

Les compilateurs améliorés par Clang sont très semblables et ils partagent la plupart des options de ligne de commande. Un sous-ensemble de fonctionnalités issues de Clang a été intégré dans {{Product}} ; certaines fonctionnalités sont disponibles dans la boîte de dialogue '''[[Boîte de dialogue Options de projet|Options de projet]]'''.

===Exécution par le biais de la ligne de commande===

Il est conseillé aux utilisateurs recourant à la ligne de commande pour exécuter les compilateurs C++ amélirés par Clang d'accéder au pilote en procédant comme suit :

{{Placeholder|compiler}} -c test.cpp

ou :

{{Placeholder|compiler}} -tWCV myApplication.cpp

Dans ce cas, les compilateurs C++ améliorés par Clang s'exécutent en ayant les paramètres suivants de ligne de commande activés par défaut :

*{{Code|-fborland-extensions}}

Si vous êtes un utilisateur expérimenté de Clang et que vous souhaitez utiliser les compilateurs C++ améliorés par Clang sans accéder au pilote, vous devez transmettre {{Code|-cc1}} comme première option, afin de signaler au compilateur que vous prenez les choses en main et que vous avez un contrôle strict et total sur toutes les options. Dans ce cas, aucune option n'est injectée automatiquement à votre place, et vous devrez spécifier manuellement les paramètres de ligne de commande ci-dessus.

===Options de signalement des erreurs===

{| class="wikitable"
|-
!Commutateur
!Description
|- valign="top"
|{{Code|--warn-common}}
|Avertir concernant les symboles communs dupliqués.
|- valign="top"
|{{Code|--warn-unresolved-symbols}}
|Signaler les symboles non résolus en tant qu'avertissements.
|- valign="top"
|{{Code|--error-unresolved-symbols}}
|Signaler les symboles non résolus en tant qu'erreurs.
|}

==Recherches et chemins #include==

Les compilateurs C++ améliorés par Clang prennent en charge trois chemins en-tête/source différents :

*{{Code|-isystem}} est pour les en-têtes système inclus avec le compilateur. Les avertissements relatifs aux en-têtes trouvés sur ce chemin sont supprimés.
*{{Code|-I}} est pour les en-têtes fournis par de tierces parties.
*{{Code|-idirafter}} est pour les chemins recherchés après les chemins spécifiés via {{Code|-I}} ou {{Code|-isystem}}. Si le chemin a un caractère de début '=', ce caractère est remplacé par la valeur spécifiée via {{Code|-sysroot}}.
*{{Code|-iquote}} est pour vos propres fichiers source et en-têtes. Comme son nom le suggère, ce chemin est utilisé uniquement pour les directives contenant des guillemets : <source lang="cpp" enclose="none">#include "fichier"</source>. Si le {{Path|fichier}} nommé n'est pas trouvé, la recherche s'effectue dans les chemins spécifiés par {{Code|-I}} et {{Code|-isystem}}, comme si la directive était <source lang="cpp" enclose="none">#include <fichier></source>.

Pour plus d'informations, voir [[Include|#include]].

==Liaison avec le runtime de {{Delphi}}==

Par défaut, si vous ne spécifiez pas une cible à l'aide du commutateur de ligne de commande {{Path|-t}}, les compilateurs C++ améliorés par Clang effectuent la liaison avec le runtime de {{Delphi}}. [[BCCAARM.EXE, le compilateur C++ pour Android|BCCAARM.EXE]] :

{| class="wikitable"
|-
!Commande
!Description
|-
|
{{Path|bccaarm file.cpp}}
|
BCCAARM construit votre application comme une application console qui est liée avec le runtime de {{Delphi}}.
|-
|
<code>bccaarm -tC file.cpp</code>
|
BCCAARM construit votre application comme une application console qui n'est pas liée au runtime de {{Delphi}}.
|-
|
<code>bccaarm -tF file.cpp</code>
|
BCCAARM construit votre application comme une [[FireMonkey|application FireMonkey]].
|}

==Utilisation de la compilation parallèle==

Pour activer la [[Compilateurs C++ améliorés par Clang#Utilisation de la compilation parallèle|compilation parallèle]] sur la ligne de commande, utilisez l'option de ligne de commande {{Code|1=--jobs=<N>}}.

Pour spécifier le nombre de sous-processus à utiliser, ajoutez un nombre à l'option de ligne de commande. Par exemple, pour utiliser 2 sous-processus, utilisez {{Code|1=--jobs=2}}. Vous ne devez pas choisir un nombre de sous-processus supérieur au nombre de coeurs de votre processeur.

Pour utiliser autant de sous-processus que possible, utilisez {{code|1=--jobs=0}}.

La compilation parallèle n'est pas compatible avec les options de ligne de commande suivantes pour bcc32c et bcc64 :

*[[Options de ligne de commande des en-têtes précompilés pour les compilateurs C++ améliorés par Clang|{{Code|-emit-pch}}]]
*[[CPP64, le préprocesseur pour Windows 64 bits|{{Code|-E}}]]

{{Note|{{Product}} prend maintenant en charge <code>--jobs</code> pour Windows 64 bits Moderne (bcc64x), ce qui accélère le temps de compilation. Toutefois, l'implémentation dans bcc64x concerne spécifiquement l'option de ligne de commande <code>-emit-obj</code>. }}

==Affichage de l'aide du compilateur==

Exécutez l'exécutable de l'interface de ligne de commande du compilateur cible avec le commutateur {{Code|--help}} pour afficher l'aide de l'interface de ligne de commande. Par exemple :

:{{Code|bcc64 --help}}

Utilisez les commutateurs {{Code|-cc1}} et {{Code|--help}} pour afficher les commutateurs que vous pouvez transmettre au compilateur en utilisant l'interface de ligne de commande. Par exemple :

:{{Code|bcc64 -cc1 --help}}

{{Note|Ce sont les commutateurs que vous pouvez utiliser dans "Autres options à transmettre au compilateur", dans {{Menu|Projet > Options > Compilateur C++ > [[Options avancées du compilateur C++|Options avancées]]}} sous [[Options avancées du compilateur C++#Autres options|Autres options]].}}

==Génération des informations de dépendance==

Par défaut, l'interface en ligne de commande des compilateurs C++ améliorés par Clang utilise l'option de ligne de commande {{code|-sys-header-deps}} pour générer des informations de dépendance complètes, y compris les fichiers en-tête système.

==Rubriques==

*[[BCC32C.EXE|BCC32C.EXE]]
*[[BCC32X.EXE|BCC32X.EXE]]
*[[BCC64.EXE, le compilateur C++ Windows 64 bits|BCC64.EXE]]
*[[BCC64X.EXE, le compilateur C++ Windows 64 bits|BCC64X.EXE]]
*[[BCCIOSARM64.EXE, le compilateur C++ pour le périphérique iOS 64 bits|BCCIOSARM64.EXE]]
*[[BCCAARM.EXE, le compilateur C++ pour Android|BCCAARM.EXE]]

==Voir aussi==

*[[Compilateurs C++ améliorés par Clang|Compilateurs C++ améliorés par Clang]]
*[[Interfaces de ligne de commande des compilateurs Delphi basés sur LLVM|Interfaces de ligne de commande des compilateurs {{Delphi}} basés sur LLVM]]

Construction

Yukikoi — Fri, 09 Oct 2026 18:13:03 GMT

Yukikoi a importé Construction par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Boîte de dialogue Options de projet}}

{{Menu|Projet > Options > Construction}}

Certaines des options répertoriées ci-dessous sont disponibles pour des langages de programmation ou des types de projets spécifiques uniquement.

==Pages enfant==

* [[C++ (options partagées)|C++ (options partagées)]]
*[[Compilateur C++|Compilateur C++]]
** [[Options avancées du compilateur C++|Options avancées]]
** [[Compatibilité du compilateur C++|Compatibilité]]
** [[Compilateur C++ - Débogage|Débogage]]
** [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]
** [[Compilateur LSP C++|LSP]]
** [[Compilateur C++ - Optimisations|Optimisations]]
** [[Compilateur C++ - Sortie|Sortie]]
** [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]
** [[Compilateur C++ - Avertissements|Avertissements]]
* [[Bibliothécaire (TLib)|Bibliothécaire (TLib)]]
*[[Lieur C++|Lieur C++]]
** [[Sortie du lieur C++|Sortie]]
** [[Avertissements du lieur C++|Avertissements]]
*[[Compilateur Delphi|Compilateur Delphi]]
** [[Compilation|Compilation]]
** [[Conseils et avertissements|Conseils et avertissements]]
** [[Liaison (Delphi)|Liaison]]
** [[Sortie - C/C++|Sortie - C/C++]]
* [[Lieurs externes utilisés par Delphi (et C++)|Lieurs externes utilisés par Delphi (et C++)]]
*[[Options du compilateur de ressources|Compilateur de ressources]]
** [[Répertoires et Conditions du compilateur de ressources|Répertoires et Conditions]]
*[[Options Turbo Assembleur|Turbo Assembleur]]
** [[Répertoires et Conditions Turbo Assembleur|Répertoires et Conditions]]
** [[Turbo Assembleur - Avertissements|Avertissements]]
* [[Evénements de construction|Evénements de construction]]
* [[Ordre de construction|Ordre de construction]]

[[Category:Référence EDI]]

WebStencils

Yukikoi — Fri, 09 Oct 2026 18:13:03 GMT

Yukikoi a importé WebStencils par téléversement de fichier (1 version) LOC-23451

Nouvelle page

WebStencils, un système d'intégration et de traitement des fichiers HTML côté serveur, a été introduit dans {{Product}} version 12.2 pour les technologies WebBroker et RAD Server. Cette fonctionnalité flexible permet aux développeurs de concevoir des sites web modernes basés sur n'importe quelle bibliothèque JavaScript tout en exploitant les données extraites et traitées par une application serveur RAD Studio. Cette technologie offre une grande flexibilité pour créer des sites web adaptés à vos besoins spécifiques.

WebStencils a pour objectif de faciliter la création de sites de navigation par l'adoption des technologies Web (WebBroker, DataSnap, RAD Server) en fournissant des scripts côté serveur. Il est ainsi possible de générer des pages HTML avec des outils standard et d'utiliser n'importe quelle bibliothèque CSS et JavaScript tout en ajoutant des données à partir des pages générées depuis l'application (il peut s'agir par exemple du résultat d'une requête de base de données).

De plus, WebStencils constitue une excellente base pour le développement Web avec HTMX. Les pages HTMX bénéficient de la génération de code côté serveur et peuvent se connecter à des serveurs REST pour la mise à jour du contenu. Les technologies Web de Delphi offrent des fonctionnalités de génération de page et d'API REST de très haut niveau.

==Syntaxe de WebStencil==

Le langage de script de WebStencils repose sur deux éléments et est relativement simple :

* Le {{code|'''@''' }}
* Les accolades {{code| '''{ }''' }}

===Utilisation du symbole {{code|@}}===

WebStencils utilise le symbole {{code|'''@'''}} comme marqueur spécial plutôt que des balises HTML/XML ou d'autres notations. Le symbole {{code|'''@'''}} est suivi par :

* Le nom d'un objet ou d'un champ.
* Un [[WebStencils#Mots clé de WebStencils|mot clé spécial]].
* Un autre symbole {{code|'''@'''}}. {{Tip| L'utilisation du symbole {{code|'''@'''}} est plus souple. Ainsi, vous n'aurez pas besoin de le doubler dans certaines situations, comme dans les en-têtes.}}

L'accès général à une valeur est basé sur une notation par point, sous la forme object.value. C'est pourquoi vous observerez des balises comme :

@object.value

Le nom de '''l'objet''' est un nom symbolique local qui peut correspondre à un objet réel d'une application serveur, assigné à l'exécution du script via un processus de recensement. Il peut aussi être résolu dans le code lors du traitement d'un gestionnaire d'événement OnGetValue.

La valeur est composée du nom de la propriété (pour un objet générique), du nom d'un champ (si l'objet hérite de TDataSet), et d'une chaîne qui est transmise dans le gestionnaire d'événement OnGetValue associé au processeur.

{{Note|La sortie des valeurs traitées par WebStencils est chiffrée avec la méthode TNetEncoding.HTML.Encode. Vous pouvez supprimer le chiffrement en utilisant la syntaxe {{code|@\value}}.}}

====Accès aux ensembles de données et objets imbriqués====

Vous pouvez aussi utiliser le symbole {{code|'''@'''}} pour accéder à des ensembles de données et des objets imbriqués en utilisant la syntaxe suggérée dans les scénarios suivants :

* Objets et classes imbriqués :<source lang="delphi">
@MyObject.SubObject.ProperyName</source>
* Tables dans les ensembles de données imbriqués :<source lang="delphi">
@MyDataSet.DataSetField.SubField</source>

===Utilisation des accolades pour les blocs {{code|{}}}===

La seconde notation utilise des accolades, {{code|{}} et {{code|}}}, pour indiquer les blocs conditionnels ou répétés.

Toute autre utilisation des accolades dans le fichier de code source (le fichier HTML) est ignorée. En d'autres termes, les accolades ne sont traitées que si elles sont utilisées après une instruction conditionnelle WebStencils spécifique.

===Accès à des valeurs avec la notation par point===

Prenons en exemple l'extrait de code HTML WebStencils ci-dessous :<source lang="delphi">
<h2>GetValue</h2>
<p>Value obtained from data: @data.name</p>
<p>Value obtained with request @@data.value: @data.value</p></source>

Les symboles {{code|@@}} sont ignorés (nous attendons un seul {{code|@}} en sortie). Il suffit d'un seul pour déclencher le traitement.
Notez également que les deux symboles, le nom d'objet et le nom de valeur, doivent être des identificateurs Delphi valides et ne peuvent pas contenir d'espaces ni commencer par un chiffre. Un nom peut contenir des caractères de soulignement et des chiffres.

===Gestionnaire d'événement OnValue===

Il est possible de fournir des données en utilisant un composant avec le gestionnaire d'événement OnValue. Par exemple :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebStencilsValueFromEventValue(Sender: TObject;
const ObjectName, FieldName: string; var ReplaceText: string;
var Handled: Boolean)
begin
if SameText (ObjectName, 'data') then
begin
Handled := True;
ReplaceText := 'You requested ' + FieldName;
end;
end;</source>

Dans le code exemple ci-dessus, le code vérifie uniquement le nom d'objet (la première partie du symbole avant le point), mais il est recommandé de vérifier également la propriété FieldName (le symbole après le point).

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebStencilsValueFromEventValue(TObject *Sender,
const String ObjectName, const String FieldName, String &ReplaceText, bool &Handled)
{
if (SameText(ObjectName, "data"))
{
Handled = true;
ReplaceText = "You requested " + FieldName;
}
}</source>

Dans l'exemple ci-dessus, {{code|String}} est une chaîne {{code|UnicodeString}} compatible Delphi dans C++ Builder. {{code|SameText}} est une fonction de comparaison de chaînes insensible à la casse fournie par SysUtils. Enfin, {{code|&ReplaceText}} et {{code|&Handled}} sont transmis par référence pour permettre la modification et reproduire le comportement {{code|var}} de Delphi.

===Utilisation d'un objet dans le dictionnaire de variables de script===

Une autre approche consiste à fournir les valeurs en utilisant un objet. Dans ce cas, l'objet doit être configuré et associé à l'action du producteur.

Voici un exemple complet, supposant une classe TMyObject et sa propriété Name :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule1.WebModule1WebActionItem2Action(Sender: TObject;
Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
begin
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetValue</h2>
<p>Value obtained from data: @world.Name</p>
''';
var MyObj := TMyObject.Create();
MyObj.Name := 'Hello hello';
WebStencilsProcessor1.AddVar('world', MyObj, True);
Response.Content := WebStencilsProcessor1.Content;
Handled := True;
end;</source>

Cet exemple donne le résultat suivant :

"Value obtained from data: Hello Hello"

Notez que l'objet est recensé avec le nom 'world', qui sera ensuite utilisé dans le script WebStencils.

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule1::WebModule1WebActionItem2Action(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
WebStencilsProcessor1->InputLines->Text =
"<h2>GetValue</h2>\n"
"<p>Value obtained from data: @world.Name</p>";

TMyObject *MyObj = new TMyObject();
MyObj->Name = "Hello hello";

WebStencilsProcessor1->AddVar("world", MyObj, true);

Response->Content = WebStencilsProcessor1->Content;
Handled = true;
}</source>

===Expressions===

Voici la liste des expressions prises en charge :

*{{code|'''@ (<expression>)'''}} - marqueurs de variable. L'expression doit être écrite entre parenthèses.
*{{code|'''@if (<expression>)'''}} - commande "if". L'expression doit être écrite entre parenthèses.
*{{code|'''@Import (<expression>)'''}}, {{code|'''@LayoutPage (<expression>)'''}}, {{code|'''@AddPage (<expression>)'''}} - ''commandes de fichier. L'expression doit être écrite entre accolades.''

L'exemple suivant montre uniquement les différences entre les options ci-dessus :<source lang="delphi">
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetExpression</h2>
<p>Value obtained from data: @(world.value*2)</p>
''';
MyObj.Value := 2;</source>

Vous obtenez alors la sortie suivante :

"Value obtained from data: 4"

En plus des expressions simples, vous pouvez étendre le système en utilisant des appels de fonction personnalisés. Voici un exemple de code qui recense une fonction “'''Concat'''” recevant deux paramètres chaîne :<br />'''Delphi :'''<source lang="delphi">
uses
System.Bindings.EvalProtocol, System.Bindings.Methods;

TBindingMethodsFactory.RegisterMethod(
TMethodDescription.Create(
MakeInvokable(function(Args: TArray<IValue>): IValue
begin
Result := TValueWrapper.Create(
Args[0].GetValue.AsString + Args[1].GetValue.AsString);
end),
'Concat', 'Concat', '', True, '', nil));</source>

Dans un script WebStencils, vous pouvez l'utiliser dans une expression comme :

@(Concat('aaa', 'bbb']]

'''C++ :'''<source lang="cpp">
#include <System.Bindings.EvalProtocol.hpp>
#include <System.Bindings.Methods.hpp>
#include <System.Rtti.hpp>
#include <System.SysUtils.hpp>

using namespace System::Bindings::EvalProtocol;
using namespace System::Bindings::Methods;
using namespace System::Rtti;

class TValueWrapper : public TInterfacedObject, public IValue
{
private:
TValue FValue;

public:
__fastcall TValueWrapper(const TValue &AValue) : FValue(AValue) {}

virtual TValue __fastcall GetValue() { return FValue; }

// Implement other IValue methods as needed...
};

void RegisterCustomBindingMethod()
{
TBindingMethodsFactory::RegisterMethod(
new TMethodDescription(
MakeInvokable([](const TArray<IValue*> &Args) -> IValue*
{
String s1 = Args[0]->GetValue().ToString();
String s2 = Args[1]->GetValue().ToString();
return new TValueWrapper(TValue::From<String>(s1 + s2));
}),
"Concat", "Concat", "", true, "", nullptr));
}</source>

====Instruction Switch====

En plus de l'instruction {{code|@if}}, les utilisateurs peuvent choisir d'utiliser les instructions {{code|@switch}} ou {{code|@case}}.<br />
Voici un exemple de syntaxe :<source>
@switch(@user.role) {
@case "admin" {
<div>Admin Panel</div>
} @case "moderator" {
<div>Moderator Tools</div>
} @default {
<div>Regular User View</div>
}
}</source>

A partir de l'exemple ci-dessus, notez que :

*Les valeurs des "case" peuvent être des littéraux ou des expressions utilisant {{code|@}}(expression).
*Seul le premier "case" correspondant est exécuté.
*L'utilisation de {{code|@default}} est facultative et s'exécute s'il n'y a pas de correspondance avec "case"'.

===Utilisation d'un ensemble de données===

Une alternative consiste à utiliser l'enregistrement en cours d'un ensemble de données plutôt qu'un objet. Dans ce cas, votre code sera comme suit :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebModule13waCompanyAction(Sender: TObject;
Request: TWebRequest; Response: TWebResponse;
var Handled: Boolean];
begin
ClientDataSet1.Open;
if not WebStencilsValueFromObject.InVars ('dataset'] then
WebStencilsValueFromObject.AddVar(
'dataset', ClientDataSet1, False]; // False = do not destroy
Response.Content := WebStencilsValueFromObject.Content;
ClientDataSet1.Close;
end;</source>

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebModule13waCompanyAction(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
ClientDataSet1->Open();

if (!WebStencilsValueFromObject->InVars("dataset"))
{
WebStencilsValueFromObject->AddVar("dataset", ClientDataSet1, false); // false = do not destroy
}

Response->Content = WebStencilsValueFromObject->Content;

ClientDataSet1->Close();
}</source>

Le code HTML correspondant peut contenir des références à certains champs de l'enregistrement. Voici un exemple de résultat :<source lang="delphi">
<div class="list-group w-50">
@foreach dataset {
<a href="/company?id=@loop.custno" class="list-group-item
list-group-item-action" aria-current="true">
<div class="d-flex w-100 justify-content-between">
<h5 class="mb-1">@loop.company</h5>
<small>@loop.country</small>
</div>
<p class="mb-1">@loop.city</p>
<small>@loop.state</small>
</a>
}</source>

====Accès aux propriétés de l'ensemble de données====

La notation WebStencils {{code|@}} relative à un ensemble de données permet d'accéder aux propriétés de l'ensemble de données, en plus de ses champs. Les utilisateurs peuvent utiliser {{code|@data.RecordCount}} pour accéder à la propriété RecordCount. En cas de conflit, les champs de l'ensemble de données ont priorité sur les propriétés portant le même nom.

Cela inclut l'accès aux informations des champs, comme suit :

@foreach field in customers.fields

Ainsi que l'accès aux propriétés des champs :<source>
@foreach customer in customers {
@customer.address.visible
@customer.phone.displaylabel
}</source>

==Utilisation de variables de modules==

Alternativement, pour recenser un objet spécifique pour un WebStencilsProcessor, vous pouvez ajouter un “'''module'''” avec plusieurs objets. Dans ce contexte, un 'module' est une collection d'objets ou de fonctions liés entre eux. N'importe quel champ ou n'importe quelle propriété du module peut être décoré avec l'attribut {{code|'''[WebStencilsVar]'''}}, qui vous permet de spécifier comment le WebStencilsProcessor doit traiter les données.

Par exemple, supposons que votre module de données a un composant FDMemTable1 de type TFDMemTable marqué comme {{code|'''[WebStencilsVar]'''}}, et un champ LastName, vous pouvez écrire :

<source lang="delphi">

WebStencilsProcessor1.InputLines.Text := '''
<h2>GetTableData</h2>
<p>Value obtained from table: @(FDMemTable1.LastName)</p>
''';
WebStencilsProcessor1.AddModule(self);</source>L'exemple ci-dessous renvoie la valeur de LastName dans le premier enregistrement. Utilisez une boucle {{code|'''@for'''}} pour afficher tous les enregistrements.

===Utilisation de variables supplémentaires===

Ajoutez des variables supplémentaires au moteur de script à l'extérieur des modèles d'objet et d'ensemble de données. Plutôt que d'ajouter une structure de données spécifique, ce mécanisme propose une méthode anonyme qui permet d'implémenter une recherche personnalisée dans une structure de données personnalisée. Il s'agit des méthodes suivantes :

TWebStencilsDataVars.Add(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsProcessor.AddVar(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsEngine.AddVar(LookupFunc), AddInitFunc(LookupFunc)

Voici un exemple :

<source lang="delphi">
type
TMap = TDictionary<string, string>;
var
LDict: TMap;
begin
LDict := TMap.Create;
LDict.Add('APP_VERSION', '1.0.0');
LDict.Add('APP_NAME', 'WebStencils demo');
LDict.Add('COMPANY_NAME', 'Embarcadero Inc.');
LDict.Add('DEBUG_MODE', 'True');

FWebStencilsProcessor.AddVar('env', LDict, True,
function(AVar: TWebStencilsDataVar; const APropName: string;
var AValue: string): Boolean
begin
Result := TMap(AVar.TheObject).TryGetValue(APropName.ToUpper, AValue);
end);</source>

Vous pouvez aussi l'utiliser dans un modèle, comme suit :

<source>
@env.APP_NAME - @env.APP_VERSION
@if env.DEBUG_MODE {
<div>Debug mode active</div>
}</source>

==Mots clés de WebStencil==

Le moteur WebStencils utilise les balises suivantes sous forme de mots clés (notez que ces noms ne peuvent pas être utilisés pour des variables de script).

{| class="wikitable"
|-
!Mot clé
!Description
|-
|{{code| '''@query'''}}
|Utilisé pour lire des paramètres de requête HTTP.
|-
|{{code| '''@page'''}}
|Fournit l'accès au nom de la page et aux arguments de l'URL (voir la propriété [[WebStencils#Utilisation de WebStencils avec RAD Server|PathTemplate]] pour plus d'informations). Il est possible d'accéder au chemin de l'URL en utilisant l'une de ces valeurs :
*{{code|@page.request_path}}
*{{code|@page.request_segment}}
|-
|{{code| '''@lang'''}}
|Utilisé pour la prise en charge de la traduction, déclenche un événement OnLang distinct plutôt que l'événement OnValue.
|-
|{{code| '''@* .. *@'''}}
|Utilisé pour ajouter des commentaires dans le script, qui seront omis dans le HTML résultant.
|-
|{{code| '''@if'''}} object.value { … } ['''@else''' { … }]
|Exécute le bloc suivant entre accolades uniquement si la valeur vaut {{code|true}}.
|-
|{{code| '''@if (<expression>)'''}}
|Utilisé pour restituer du contenu de façon conditionnelle. Si l'expression est évaluée à {{code|true}}, le contenu associé est inclus dans la sortie ; sinon il est omis.
|-
|{{code| '''@if not''' object.value { ... } ['''@else''' { … }]}}
|Exécute le bloc suivant entre accolades uniquement si la valeur ne vaut pas {{code|true}}. <br />Par exemple :
<source lang="delphi">
@if obj1.ValueBelowTen {
<p>@obj1.name <span> has a value of </span> @obj1.value</p>
}</source>
|-
|{{code| '''@ForEach''' (var object in list) { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement :
*Les ensembles de données
*TObjectList, doit être ajouté au dictionnaire de processeur.
*Tout objet possédant la méthode GetEnumerator, où l'énumérateur renvoie une valeur d'objet.
|-
|{{code| '''@ForEach''' object { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement les ensembles de données et TObjectList, qui doivent être ajoutés en tant que variables de script.
|-
|{{code|'''@loop'''}}
|Utilisez à l'intérieur d'un bloc pour faire référence à l'élément en cours de l'énumération (liste ou ensemble de données). Il doit être suivi du nom d'une propriété ou d'un champ sans utiliser de nom d'objet.
|-
|{{code|'''@Import'''}}
|Permet de fusionner un fichier externe à un emplacement spécifique du fichier externe. Suppose toutefois que le nom de fichier ait l'extension .HTML. <br />Le format doit être comme suit :
<source lang="delphi">
@import filename [ {<alias1> = <var1> [..., <aliasN> = <varN>]} ]</source>
|-
|{{code|'''@Scaffolding'''}}
|Espace réservé pour le scaffolding. Ce mécanisme permet de générer dynamiquement du code HTML à partir de la structure de données d'une application (les propriétés d'un objet et les champs d'une base de données). Le code HTML généré côté serveur peut inclure d'autres balises pour accéder aux données. <br />Le code suivant est un exemple de disposition HTML simple générée dans le gestionnaire d'événement OnScaffolding pour chacun des champs de la base de données.
<source lang="delphi">
procedure TWebModule1.ProcessorCompanyScaffolding(Sender: TObject;
const AQualifClassName: string; var AReplaceText: string);
begin
if SameText (AQualifClassName, 'Company') then
begin
AReplaceText := '';
for var I := 0 to ClientDataSet1.Fields.Count -1 do
AReplaceText := AReplaceText + '<p>'+
ClientDataSet1.Fields[I].FieldName +
': @dataset.' + ClientDataSet1.Fields[I].FieldName + '</p>';
end;
end;</source>
|-
|{{code|'''@switch'''}}, {{code|'''@case'''}}, {{code|'''@default'''}}
|Effectue un rendu conditionnel à branches multiples. Après avoir évalué une expression, la met en correspondance avec les valeurs définies avec @case, en restituant le bloc correspondant. La directive @default est utilisée si aucune correspondance n'est trouvée pour @case.
|-
|{{code|'''@LoginRequired'''}}
|Arrête l'exécution si une connexion est requise alors que l'utilisateur n'est pas connecté.
|-
|{{code|'''@LoginRequired (<role>)'''}}
|Le moteur vérifie que l'utilisateur est connecté, mais aussi qu'il dispose du rôle spécifique actif, ce qui restreint l'accès à la page selon la permission.<br /> Par exemple : '''@LoginRequired (admin)'''
|}

===Alias d'importation===

L'exemple ci-dessous illustre comment utiliser des alias d'importation.<source lang="delphi">
@import one {@o1 = @object, @d1 = @data} Hello</source>

Dans ce code, '''@object''' et '''@data''' sont les véritables variables dans le script exécuté. Les alias '''@o1''' et '''@d1''' sont des variables de script pour le script "one" et sont accessibles dans ce script comme des variables normales. Ainsi, vous pouvez transmettre au script QA des variables portant des noms différents, en fournissant comme alias le nom attendu par le script.

==Modèles WebStencils : disposition et corps==

La capacité à fusionner un modèle HTML partagé avec le contenu d'une page compte parmi les fonctionnalités indispensables d'un moteur de modèle. Cette opération s'effectue (comme dans la version .NET) en utilisant quatre symboles spéciaux :

* '''@LayoutPage filename''' : cette commande est utilisée dans une page HTML spécifique (généralement en haut de page) pour indiquer le fichier de modèle à utiliser comme structure de la page. Plusieurs pages peuvent partager un même modèle, mais toutes les pages d'un projet (même en utilisant TWebStencilsEngine) ou d'un dossier virtuel n'ont pas nécessairement besoin d'utiliser le même modèle.

:{{Note| Cette commande ne doit être utilisée qu'une seule fois par page. Si vous tentez d'utiliser plusieurs fois '''@LayoutPage''', une exception se déclenche et bloque la commande.}}

* '''@RenderBody''' : cette commande sans paramètre est une marque de réservation dans un fichier de modèle qui indique où placer le contenu d'une page spécifique.

Voici un exemple d'utilisation de '''@LayoutPage''' et de '''@RenderBody''' :

'''Test.html'''<source lang="delphi">
@LayoutPage BaseTemplate
<h2>Page Test3</h2>
<p>Local data param one is @page.name (the page name)</p></source>

'''BaseTemplate.html'''<source lang="delphi">
<html lang="en">
<head>

@extends layouts/intermediate
@ExtraHeader {
<style>.highlight { color: green; }</style>
}


@extends layouts/base
@ExtraHeader {
<meta name="viewport" content="width=device-width, initial-scale=1">
}


<head>
@RenderHeader
</head></source>

Dans l'exemple ci-dessus, le CSS de {{code|page.html}} et la balise meta de {{code|intermediate.html}} sont injectés dans la sortie finale de {{code|@RenderHeader}}.

==Composants de WebStencils==

Le package WebStencils installe deux composants différents : un processeur de fichier unique et un moteur qui instancie des processeurs individuels et fournit une configuration globale pour les processeurs autonomes ou ceux auxquels ils sont manuellement connectés.

Le composant principal prend un fichier HTML, incorpore la notation WebStencils et le convertit en HTML brut après avoir traité les balises {{code|'''@'''}}.

La classe '''TWebStencilsProcessor''' traite un fichier individuel (généralement ayant une extension HTML) et son modèle associé, le cas échéant. Le processeur peut être utilisé de façon autonome et assigné au '''TWebActionItem.Producer''', ou être créé et appelé par TWebStencilsEngine en tant que post-processeur de fichiers texte renvoyés par un répartiteur de fichiers.

===Composant WebStencilsEngine===

Le composant '''Engine''' peut être utilisé dans les deux scénarios suivants :

*Pour le connecter à un ou plusieurs composants '''WebStencilsProcessor''' et fournir des comportements et des paramètres partagés.
*Pour créer des composants '''WebStencilsProcessor''' lorsque cela est nécessaire, et placer uniquement ce composant sur vos modules web.

==Intégration automatique de sessions==

Lorsqu'elles sont disponibles, [[WebStencils|WebStencils]] peut automatiquement s'intégrer à des sessions web. Aucune configuration supplémentaire n'est nécessaire. Tout se fait automatiquement dès lors que {{code|WebRequest.Sessions}} existe.

Les données des sessions sont accessibles via {{code|@session.property}}. Tous les objets dans {{code|WebRequest.Session.DataVars}} sont automatiquement recensés en tant que variables de modèles. De même, {{code|UserLoggedIn}} et {{code|UserRoles}} sont automatiquement remplis à partir de {{code|WebRequest.Session.User}}.

En voici un exemple :<source>
@if session.Authenticated {
<div>User authenticated</div>
@session.sessionid
}

@if session.UserHasRole(‘admin’) {
<div>User is an Admin</div>
}</source>

==Liste blanche de sécurité==

Pour des raisons de sécurité, WebStencils implémente un mécanisme de liste blanche de propriétés pour éviter l'exposition d'informations sensibles comme les chaînes de connexion aux bases de données. Par défaut, seules les propriétés sécurisées sont accessibles. Voici la liste des propriétés sécurisées :

*Pour les '''TDataSet''' : Active, FieldByName, First, Last, Next, Prior, Bof, Eof, FieldCount, Fields, Found, RecordCount, RecNo.
*Pour les '''TStrings''' : Contains, ContainsName, IndexOf, IndexOfName, CommaText, Count, IsEmpty, DelimitedText, Names, KeyNames, Values, ValueFromIndex, Strings, Text.

===Personnalisation de la liste blanche===

La liste blanche peut être personnalisée en utilisant la propriété [[lib_fr:Web.Stencils.TWebStencilsProcessor.Whitelist|TWebStencilsProcessor.Whitelist]]. La méthode de configuration permet aux utilisateurs de spécifier les membres autorisés et ceux bloqués. Voir l'exemple ci-dessous :<source>
procedure Configure(const AClass: <PTypeInfo, TClass, TObject>;
const AAllowedMembers: TArray<string>;
const ABlockedMembers: TArray<string>;
AReset: Boolean);</source>

* '''AClass''' : le type PTypeInfo/TClass/TObject pour configurer des éléments tels que des TDataSet, TStrings.
* '''AAllowedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite autoriser.
* '''ABlockedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite bloquer.
* '''AReset''' : {{code|True}} lorsqu'utilisé pour remplacer une liste blanche existante, ou {{code|False}} pour ajouter des éléments à la liste.

Voici un exemple qui illustre comment ajouter des membres autorisés supplémentaires à une liste blanche existante :<source>
TWebStencilsProcessor.Whitelist.Configure(TMyClass,
['CustomProp'], nil, False);</source>

Voici un exemple qui illustre comment remplacer la totalité d'une liste blanche (AReset = True) :<source>
TWebStencilsProcessor.Whitelist.Configure(TDataSet,
['RecordCount', 'RecNo'], nil, True);</source>

Voici un exemple qui illustre comment bloquer certains membres :<source>
TWebStencilsProcessor.Whitelist.Configure(MyObject,
nil, ['CustomProp'], False);</source>

La liste blanche s'applique à l'ensemble de l'application et à tous les WebStencils.

==Utilisation de WebStencils avec RAD Server==

La bibliothèque de modèles WebStencils peut aussi être utilisée dans une application RAD Server. Il est recommandé de combiner le composant ''TEMSFileResource''' existant avec un composant '''TWebStencilsEngine'''. Le premier permet de mapper le système de fichiers, alors que le second gère le mappage HTTP et le traitement des modèles. Les composants sont connectés en utilisant la propriété Dispatcher du moteur WebStencil.

L'exemple ci-dessous illustre la configuration nécessaire pour ajouter deux composants à un module web RAD Server :<source lang="delphi">
object html: TEMSFileResource
PathTemplate = '..\..\html\{filename}'
end
object WebStencilsEngine1: TWebStencilsEngine
Dispatcher = html
PathTemplates = <
item
Template = '/'
Redirect = '/test1.html'
end
item
Template = '/list'
Redirect = '/companylist.html'
end
item
Template = '/company'
OnPathInit = WebStencilsEngine1PathTemplates2PathInit
end
...>
end</source>

Les PathTemplates sont utilisés pour mapper les URL entrantes à des fichiers. En mode conception, la configuration se présente comme suit :

[[File:PathTemplates WebStencils.png|350px|=link]]

De plus, il est nécessaire de configurer le mappage de plus haut niveau dans le module de données :

<source lang="delphi">
type
[ResourceName('testfile')]
TTestfileResource1 = class(TDataModule)
[ResourceSuffix('./')]
[ResourceSuffix('get', './')]
[EndpointProduce('get', 'text/html')]
html: TEMSFileResource;</source>

Pour mapper plusieurs chemins différents (à la différence de l'exemple ci-dessus), ajoutez des composants '''TEMSFileResource'''. Le composant '''TWebStencilsEngine''' peut comporter un seul dispatcher dans la propriété correspondante. Pour associer davantage de dispatchers, utilisez le code suivant :

<source lang="delphi">
AddProcessor(html2, WebStencilsEngine1);</source>

==Voir aussi==

*[[Présentation de RAD Server|Présentation de RAD Server]]

Utilisation de la directive de packaging faible

Yukikoi — Fri, 09 Oct 2026 18:13:03 GMT

Yukikoi a importé Utilisation de la directive de packaging faible par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Compilation de packages}}

Les unités faibles (faiblement packagées) sont des unités définies dans un package (c'est-à-dire un projet package). Toutefois, la liaison est différente pour les packages liés de façon dynamique.

Normalement, une unité réside dans le package lui-même. Lorsqu'il est lié, le fichier [[Fichier de bibliothèque d'importation de package|BPI]] (bibliothèque d'importation de package) crée une référence au package.
{{Note| N'oubliez pas que le fichier [[Fichier de bibliothèque d'importation de package|BPI]] est lié au consommateur du package.}}
En revanche, une unité faiblement packagée réside dans le fichier [[Fichier de bibliothèque d'importation de package|BPI]]. Cela signifie que même pour un package lié de façon dynamique, une unité faiblement packagée est directement liée au module consommateur du package. Tout aussi important, si vous mettez à jour le fichier BPL à un autre moment que pendant la recompilation du logiciel à l'aide du fichier BPL, l'unité faiblement packagée supposément contenue dans le fichier BPL n'est pas mise à jour dans le logiciel qui l'utilise, car elle se trouve en fait dans la bibliothèque d'importation (BPI) et est donc liée dans le consommateur du package.

Si vous utilisez seulement une unité faible à partir d'un package, votre application ne dépendra pas de ce package (vous ne disposerez donc pas d'une dépendance par rapport au fichier BPL). En effet, au lieu d'un objet d'importation, le fichier BPI contient le fichier objet de l'unité (comme s'il s'agissait d'un package statique), et comme le fichier objet est lié, il n'est pas dépendant du package. En d'autres termes, les unités faiblement packagées créent un mélange de packages dynamiques et statiques, où les unités faibles sont statiques.
{{Attention| Une unité faiblement packagée ne peut pas avoir de variables globales ni d'initialisation.}}
Voici des exemples qui décrivent ce comportement pour {{Delphi}} et {{CBuilder}} :
<l s="delphi" />

={{Delphi}}=

La directive '''<code>$WEAKPACKAGEUNIT</code>''' affecte la manière dont un fichier <code>.dcu</code> est stocké dans des fichiers <code>.dcp</code> et <code>.bpl</code> d'un package.

Si '''<code>{$WEAKPACKAGEUNIT ON}</code>''' figure dans un fichier unité, le compilateur omet l'unité dans les fichiers BPL quand c'est possible, et crée une copie locale non packagée de l'unité quand elle est requise par une autre application ou un autre package. Une unité compilée avec cette directive est dite ''faiblement packagée''.

Par exemple, supposez que vous ayez créé un package appelé pack1 qui contient une seule unité, unit1. Supposez que unit1 n'utilise aucune unité supplémentaire, mais fait des appels à rare.dll. Si vous placez la directive '''<code>{$WEAKPACKAGEUNIT ON}</code>''' dans unit1.pas ({{Delphi}}) ou unit1.cpp (C++), lors de la compilation du package, unit1 n'est pas incluse dans pack1.bpl ; vous n'avez donc pas à distribuer de copie de rare.dll avec pack1. Cependant, unit1 sera toujours incluse dans pack1.dcp. Si un autre package ou une autre application utilisant pack1 fait référence à unit1, elle sera copiée depuis pack1.dcp et compilée directement dans le projet.

Supposons maintenant que vous ajoutiez à pack1 une deuxième unité, unit2, et que unit2 utilise unit1. Cette fois, même si vous compilez pack1 avec '''<code>{$WEAKPACKAGEUNIT ON}</code>''' dans unit1.pas, le compilateur inclura unit1 dans pack1.bpl.
{{Note| Les fichiers unité contenant la directive '''<code>{$WEAKPACKAGEUNIT ON}</code>''' ne doivent pas contenir de variables globales, de section d'initialisation ou de section de finalisation.}}
La directive '''<code>{$WEAKPACKAGEUNIT ON}</code>''' est une fonctionnalité avancée à l'intention des développeurs distribuant leurs packages à d'autres programmeurs. Elle vous permet d'éviter la distribution de DLL rarement utilisées et supprime les conflits entre des packages qui peuvent dépendre de la même bibliothèque externe.

Ainsi, l'unité PenWin référence PenWin.dll. La plupart des projets n'utilisent pas PenWin et la plupart des ordinateurs n'ont pas de fichier PenWin.dll installé. C'est pour cela que l'unité PenWin est faiblement packagée dans vcl. Lorsque vous compilez un projet utilisant PenWin et le package vcl, PenWin est copiée depuis vcl70.dcp et liée directement dans votre projet ; l'exécutable résultant est statiquement lié à PenWin.dll.

Si PenWin n'avait pas été faiblement packagée, deux problèmes se seraient produits. Tout d'abord, il aurait fallu que la VCL soit liée de manière statique à PenWin.dll et vous n'auriez donc pas pu le charger sur un système ne disposant pas de PenWin.dll. De plus, si vous aviez tenté de créer un package contenant PenWin, une erreur de compilation aurait eu lieu, puisque l'unité PenWin est contenue dans la VCL et dans votre package. Ainsi, sans "packaging faible", l'unité PenWin n'aurait pas pu être incluse dans des distributions standard de la VCL.
<l e="delphi" />
<l s="cpp" />

={{CBuilder}}=

La directive <code>#pragma package(smart_init, weak)</code> affecte la manière dont un fichier .obj est stocké dans les fichiers [[Fichier de bibliothèque d'importation de package|.bpi]] et [[Fichier de bibliothèque partagée de package|.bpl]] d'un package. (Pour davantage d'informations sur les fichiers générés par le compilateur et le lieur, voir [[Packages et DLL standard|Packages et DLL standard]].) Si <code>#pragma package(smart_init, weak)</code> figure dans un fichier unité, le lieur ne place pas l'unité dans les fichiers bpl si c'est possible, et crée une copie locale non packagée de l'unité si elle est nécessaire à une autre application ou un autre package. Une unité compilée avec cette directive est dite "faiblement packagée".

Supposons, par exemple, que vous avez créé un package appelé PACK ne contenant qu'une seule unité UNIT1, et que UNIT1 n'utilise aucune autre unité mais effectue des appels à RARE.dll. Si vous placez <code>#pragma package(smart_init, weak)</code> dans UNIT1.cpp lorsque vous construisez votre package, UNIT1 ne sera pas incluse dans PACK.bpl ; vous n'aurez pas à distribuer de copies de RARE.dll avec PACK. Cependant, UNIT1 sera toujours incluse dans PACK.bpi. Si un autre package ou une autre application utilisant PACK fait référence à UNIT1, celle-ci sera copiée à partir de PACK.bpi et liée directement dans le projet.

Supposons maintenant que vous ajoutiez à PACK une deuxième unité, UNIT2, et que UNIT2 utilise UNIT1. Cette fois, même si vous compilez PACK avec <code>#pragma package(smart_init, weak)</code> dans UNIT1.cpp, le lieur inclura UNIT1 dans PACK.bpl. Mais d'autres packages ou applications faisant référence à UNIT1 utiliseront la copie (non packagée) extraite de PACK.bpi.
{{Note| Les fichiers unités contenant la directive <code>#pragma package(smart_init, weak)</code> ne doivent pas contenir de variables globales.}}
<code>#pragma package(smart_init, weak)</code> est une caractéristique avancée prévue pour les programmeurs qui distribuent leurs fichiers bpl à d'autres programmeurs {{CBuilder}}. Elle vous permet d'éviter la distribution de DLL rarement utilisées et supprime les conflits entre des packages qui peuvent dépendre de la même bibliothèque externe.

Ainsi, l'unité PenWin référence PenWin.dll. La plupart des projets n'utilisent pas PenWin et la plupart des ordinateurs n'ont pas de fichier PenWin.dll installé. C'est pour cela que l'unité PenWin est faiblement packagée dans vcl. Lorsque vous liez un projet utilisant PenWin et le package vcl, PenWin est copiée depuis vcl60.bpi et liée directement dans votre projet ; l'exécutable résultant est statiquement lié à PenWin.dll.

Si PenWin n'avait pas été faiblement packagée, deux problèmes se seraient produits. Tout d'abord, il aurait fallu que vcl soit lié de manière statique à PenWin.dll et vous n'auriez donc pas pu le charger sur un ordinateur ne disposant pas de PenWin.dll. De plus, si vous tentez de créer un package contenant PenWin, une erreur de construction aurait lieu, puisque l'unité PenWin serait contenue dans vcl et dans votre package. Ainsi, sans "packaging faible", l'unité PenWin n'aurait pas pu être incluse dans les distributions standard de vcl.

Pour de plus amples informations, voir la documentation C++ sur [[Rad en: Pragma package#.23pragma_package.28smart_init.2C_weak.29|#pragma package(smart_init, weak)]] la documentation {{Delphi}} sur le [[Packaging faible|packaging faible]] et la [[Utilisation de la directive de packaging faible|directive de packaging faible]].
<l e="cpp" />

==Voir aussi==

*[[Utilisation des packages et des composants - Présentation|Utilisation des packages et des composants - Présentation]]
*[[Compilation de packages|Compilation de packages]]
*[[Directives de compilation spécifiques aux packages|Directives de compilation spécifiques aux packages]]
*Directive du compilateur {{Delphi}} [[Packaging faible|Packaging faible]]
*[[Fichier de bibliothèque d'importation de package|Fichier de bibliothèque d'importation de package]]
*[[Packages et DLL standard|Packages et DLL standard]].

[[Category:Guide du développeur Windows]]
[[Category:C++]]
[[Category:Delphi]]

Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++

Yukikoi — Fri, 09 Oct 2026 18:13:03 GMT

Yukikoi a importé Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++ par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Packages pour la nouvelle chaîne d'outils C++}}

Les dépendances d'initialisation et de finalisation des unités peuvent entraîner des problèmes. Comme il s'agit d'un problème récurrent, {{Product}} a amélioré considérablement la gestion des packages afin d'assurer un comportement cohérent lors de la liaison statique et dynamique des packages. Cette page explique ceci en détail.

{{Note| Gardez à l'esprit que lors de la liaison dynamique d'un package, un fichier BPL dynamique est utilisé. Il sera ensuite distribué avec l'application. Un BPL est un module chargé dynamiquement. En d'autres termes, c'est une DLL avec des éléments supplémentaires.<br />
Les packages sont toujours disponibles en deux versions, la seconde étant une bibliothèque statique standard. La liaison statique d'un package consiste à établir une liaison avec cette bibliothèque statique standard, ce qui signifie que le contenu du package est intégré au binaire lié. Vous n'avez donc pas besoin de redistribuer des fichiers supplémentaires avec ce package.<br />
Auparavant, la liaison dynamique et la liaison statique utilisaient des méthodes différentes pour l'initialisation et la finalisation des unités et des données, ce qui entraînait des comportements différents (et des bogues), selon la manière dont une application était liée. Désormais, une méthode unifiée simplifie et accélère la résolution des problèmes, garantissant ainsi un comportement quasi identique pour les deux types de liaisons.}}

Dans {{Delphi}}, les unités ont des interdépendances. Cela signifie qu'une unité utilise une autre unité ainsi que les types définis dans cette dernière. Des dépendances d'initialisation et de finalisation peuvent apparaître lorsqu'une unité est initialisée, autrement dit dans l'une des situations suivantes :

* Mots-clés [https://docwiki.embarcadero.com/RADStudio/Athens/en/Programs_and_Units_(Delphi)#The_Initialization_Section Initialization] et [https://docwiki.embarcadero.com/RADStudio/Athens/en/Programs_and_Units_(Delphi)#The_Finalization_Section finalization].
* [https://docwiki.embarcadero.com/RADStudio/Athens/en/Methods_(Delphi)#Class_Constructors Constructeurs ou destructeurs de classes].

Par exemple, lors de l'initialisation d'un objet qui dépend d'une autre instance d'objet ou d'une allocation située dans une autre unité, ce comportement provoque l'initialisation des unités basée sur un graphe de mappage de dépendances. Il n'existe pas de solution adaptée aux graphes de dépendances lorsqu'ils sont circulaires. Dans ce cas, des bogues sont susceptibles de se produire.

Ainsi, il est fréquent que les problèmes d'initialisation entraînent des violations d'accès au démarrage ou lors du chargement d'un package, notamment lorsqu'une unité utilisée n'a pas encore été initialisée. {{Product}} empêche et limite ces problèmes.

{{Note|Cette page traite de l'initialisation. Toutefois, ce qui est expliqué s'applique également à la finalisation, mais de manière inversée.}}

Gardez à l'esprit que seules les unités utilisées sont initialisées et finalisées que vous utilisiez la liaison dynamique ou la liaison statique. Contrairement aux chaînes d'outils précédentes (Clang 5 et versions antérieures, et classique), les références d'unité circulaires sont gérées, ainsi que les unités faiblement packagées.

==Comment les packages sont-ils initialisés dynamiquement ?==

Lorsqu'un package est chargé dynamiquement, ses unités sont initialisées récursivement avec un compteur. Cela garantit que lorsqu'un second package utilisant les mêmes unités est chargé, celles-ci ne sont pas initialisées deux fois et ne sont finalisées qu'après le déchargement du dernier package.

Les packages peuvent être dynamiquement initialisés de deux manières :

<ul><li>'''Via la [[Chargement des packages dans une application|bibliothèque d'importation de packages]], le fichier <code>.BPI</code>'''. C'est le système habituel. C'est aussi comme cela que la liaison automatique fonctionne.<br />
Cette méthode utilise le système d'initialisation par enregistrement et initialise donc uniquement les unités utilisées. Des différences dans l'ordre d'initialisation des unités peuvent apparaître si un package dépend de deux emplacements dans la même application.<br />
Supposons le scénario suivant :<ul><li><code>App.exe</code> dépend de <code>A.bpl</code> et <code>B.bpl</code></li>
<li><code>B.bpl</code> dépend de <code>A.bpl</code>.</li>
</ul>

Au chargement de <code>App.exe</code>, les unités qu'il utilise dans <code>A.bpl</code> ainsi que toutes les unités interdépendantes, sont initialisées. Cela signifie que l'intégralité du graphe de dépendances des unités est initialisée.<br />

Cependant, les unités de <code>A.bpl</code> dont dépend <code>B.bpl</code> ne sont pas initialisées. Lorsque <code>App.exe </code>charge <code>B.bpl</code>, ses dépendances sont initialisées depuis <code>A.bpl</code>. Si elles contiennent des unités de <code>A.bpl</code> ayant déjà été initialisées, ces unités ne seront pas initialisées une deuxième fois.<br />

Cela signifie que même si chaque graphe ou ensemble d'unités est initialisé correctement, il est possible que le chargement de <code>A.bpl</code> par <code>App.exe</code> avant <code>B.bpl</code> provoque un changement de l'ordre de l'initialisation des unités de A.bpl par rapport à celui obtenu si <code>App.exe</code> dépendait uniquement de <code>B.bpl</code> ou le chargement s'était effectué dans l'ordre <code>B.bpl</code> (-> <code>A.bpl</code>) puis <code>A.bpl</code>. Ce comportement n'impacte normalement pas la stabilité, car toutes les unités utilisées sont initialisées dans l'ordre correct défini par les enregistrements d'initialisation.

</li>
<li> '''Via [[Chargement des packages avec la fonction LoadPackage|SysUtils::LoadPackage]]'''. Avec cette méthode, les packages sont chargés dynamiquement.<br />

Toutes les unités dépendantes du package sont initialisées récursivement, qu'elles soient utilisées ou non, car il est impossible de savoir lesquelles sont utilisées par le module de chargement.<br />

Lorsqu'un package est chargé, ses dépendances le sont aussi. Cela signifie que si vous chargez un package <code>Package1.bpl</code> qui dépend de <code>rtl.bpl</code> en le liant dynamiquement ou en utilisant <code>[[Chargement des packages avec la fonction LoadPackage|LoadPackage]]</code>, ni vous ni <code>Package1.bpl</code> n'avez besoin d'appeler <code>LoadPackage(“rtlXXX.bpl”)</code>, car le chargement de <code>Package1.bpl</code> provoque le chargement et l'initialisation de toutes les unités de package dépendantes utilisées par <code>Package1.bpl</code>. Cela inclut la gestion des dépendances des unités contenues dans d'autres packages, comme <code>rtl.bpl</code>.</li>
</ul>

Une application peut mélanger les deux méthodes de chargement dynamique des packages, mais elle ne doit pas mélanger liaison statique et liaison dynamique.

L'initialisation et la finalisation des unités deviennent plus complexes à mesure que les niveaux de dépendances augmentent au sein d'un package et entre les packages. Des tests approfondis sont nécessaires pour tester les dépendances complexes.

Lors d'une liaison statique, seules les unités utilisées sont initialisées. Le lieur supprime les objets inutilisés, ce qui signifie que les unités non référencées ou non utilisées n'existent pas dans le binaire final.

===Voir aussi===

* [[Chargement des packages dans une application|Chargement des packages dans une application]]
* [[Chargement des packages avec la fonction LoadPackage|Chargement des packages avec la fonction LoadPackage]]
* [[Delphi RTTI et C++Builder|RTTI de Delphi et C++Builder]]
* [[Utilisation de la directive de packaging faible|Utilisation de la directive de package faible]]

Présentation de l'EDI

Yukikoi — Fri, 09 Oct 2026 18:13:03 GMT

Yukikoi a importé Présentation de l'EDI par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Introduction à RAD Studio}}

Quand vous démarrez {{Variables|Product}}, l'environnement de développement intégré (EDI) s'ouvre et affiche plusieurs outils et menus. L'EDI vous aide à concevoir visuellement des interfaces utilisateur, à définir les propriétés des objets, à voir et gérer votre application de diverses façons.

Cette rubrique d'aide décrit les outils qui sont disponibles dans l'EDI. Sachez que les outils spécifiques qui sont disponibles varient selon l'édition de {{Variables|Product}} que vous utilisez.

==Page d'accueil==

Lorsque vous ouvrez {{Product}}, les sections de la '''[[Page d'accueil|page d'accueil]]''' affichent différents types d'informations utiles et proposent des actions.

La '''page d'accueil''' comporte plusieurs cadres que vous pouvez ajouter, supprimer, repositionner ou redimensionner comme vous le souhaitez pour organiser les sections avec les informations que vous considérez comme les plus utiles pour commencer.

Si vous fermez la '''page d'accueil''', vous pouvez la rouvrir en choisissant {{Menu|Voir > Page d'accueil}}.

[[File:Welcome page1.png|border|link=|950px]]

{{Note| Une balise '''[Administrateur]''' s'affiche au début du libellé de la barre de titre lorsque vous exécutez '''l'EDI''' avec des privilèges élevés.}}

==[[Style EDI|Thème foncé]]==

{{Product}} {{Version}} vous permet de choisir un thème foncé pour l'EDI. Le thème foncé s'applique à un schéma de couleurs complètement différent et fournit une apparence adaptée à une utilisation prolongée ou à un environnement à faible luminosité.

Les options du thème EDI vous permettent de réaliser les actions suivantes :

*Faire correspondre au thème Windows
*Activer le thème foncé
*Activer le thème clair
*Activer le thème Mountain Mist
*Choisir les couleurs prédéfinies pour l'éditeur et pour l'inspecteur d'objets indépendamment du thème de l'EDI sélectionné.
*Choisir la couleur de la barre de titre

Pour accéder aux options relatives aux thèmes de l'EDI, choisissez {{Menu|Outils > Options > Interface utilisateur > [[Style EDI|Style de l'EDI]]}} ou cliquez sur le menu déroulant accessible dans la barre supérieure, à côté de la zone de liste déroulante des dispositions.

[[File:Top Bar Menu.png|link=]]

==Options d'accessibilité==

Avec l'EDI, vous pouvez utiliser les outils MSAA (MS Active Accessibility). Vous pouvez activer les outils d'accessibilité de Windows à partir du menu Démarrer via <font color="#598527">'''Tous les programmes > Accessoires > Accessibilité'''</font>.

==Dispositions du bureau et option d'auto-enregistrement Bureau du projet==

La disposition du bureau par défaut de l'EDI comporte les outils les plus fréquemment utilisés ({{Menu|Outils > Options > EDI > [[Bureau et disposition|Bureau et Disposition]]}}). Vous pouvez utiliser le menu Voir pour afficher ou masquer certains outils. Vous pouvez aussi personnaliser votre bureau en déplaçant et en supprimant des éléments, et [[Enregistrement des dispositions du bureau|enregistrer les dispositions du bureau]] qui vous conviennent le mieux.

Les paramètres du bureau sont enregistrés dans un fichier <code>.dsk</code>, et l'option '''d'enregistrement automatique du bureau du projet''' (sur {{Menu|Outils > Options > EDI > [[Saving and Recovering|Enregistrement et récupération]]}}) permet d'enregistrer un fichier <code>.dsk</code> pour le projet en cours. Le fichier <code>.dsk</code> conserve aussi les points d'arrêt et les points de suivi en cours. Le fichier <code><monprojet>.dsk</code> est enregistré dans votre dossier projet. Voir [[Enregistrement des dispositions du bureau|Enregistrement des dispositions du bureau]].

==Onglets Editeur==

La partie centrale de la fenêtre principale de l'EDI affiche une série d'onglets avec plusieurs fichiers code source et d'autres éléments ouverts. Il s'agit de l'espace de travail central. Les onglets contiennent généralement du code source ou un concepteur de fiches, mais ils peuvent aussi contenir un éditeur spécial ou des panneaux d'information, qui ont tous des couleurs différentes pour que vous puissiez les différencier des onglets normaux de code/concepteur.

[[File:Welcome screen tabs.png|link=|550px]]

Les onglets peuvent être déplacés hors de leur fenêtre ou dupliqués en cliquant dessus avec le bouton droit et en sélectionnant '''Déplacer >''' ou '''Fractionner >''' à gauche, à droite, en haut ou en bas de l'EDI. Pour de plus amples informations, voir [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]].

Vous pouvez modifier le comportement de l'onglet (comme le bouton Fermer ou la fermeture automatique des onglets) ou l'affichage des couleurs sur la page de l'onglet [[Options de l'EDI|Options de l'EDI]].

==Utilisation d'une fiche==

{{f|webdocs|En général, une fiche représente une fenêtre ou une page HTML dans l'interface utilisateur que vous concevez.|En général, une fiche représente une fenêtre dans l'interface utilisateur que vous concevez.}} Au moment de la conception, une fiche est affichée sur la surface du concepteur. Ajoutez des composants de la '''[[Palette d'outils|Palette d'outils]]''' sur la fiche pour créer votre interface utilisateur.

{{Variables|Product}} propose une bibliothèque enrichie de fiches, comme décrit dans la section suivante. Sélectionnez la fiche la plus adaptée à la conception de votre application, qu'il s'agisse d'une application Web proposant des fonctionnalités de logique métier via le Web ou une application Windows proposant le traitement et l'affichage performant de contenu. Pour naviguer entre le concepteur et '''[[Editeur de code|l'éditeur de code]]''', cliquez sur leur onglet respectif en bas de l'EDI.

Pour accéder aux fiches, choisissez <font color="#598527">'''Fichier > Nouveau > Autre'''</font>.
{{f|vcl|2=

===Fiches VCL===

Utilisez {{Variables|VCLForms}} pour créer des applications natives utilisant des composants VCL.

Pour créer une application {{Variables|VCLForms}}, choisissez <font color="#598527"> '''Fichier > Nouveau > Autre > [[Application Fiches VCL|Application Windows VCL]]'''</font>.

Utilisez ensuite les classes de composants VCL pour créer votre application. Pour parcourir la bibliothèque VCL, voir [[lib_fr:Main Page|Référence VCL]].
}}

==Concepteur de fiches==

Le '''[[Concepteur de fiches|Concepteur de fiches]]''', ou le concepteur, est affiché automatiquement dans le volet central quand vous utilisez une fiche. L'apparence et les fonctionnalités du concepteur dépendent du type de fiche que vous utilisez. {{f|webdocs|Par exemple, si vous utilisez une fiche Web, le concepteur affiche un éditeur de balise HTML.}} Pour accéder au concepteur, cliquez sur l'onglet '''Conception''' en bas de l'EDI.

===Composants visuels===

Les composants visuels apparaissent dans la fiche lors de la conception et sont visibles pour l'utilisateur final à l'exécution. Ce sont les boutons, les libellés, les barres d'outils et les zones de liste.
{{f|vcl|2=

===Aperçu d'une fiche [[File:FormPreview.png]]===

Une icône d'aperçu en bas à droite du concepteur (pour les fiches VCL) présente le positionnement de votre fiche sur l'écran à l'exécution. Vous pouvez ainsi positionner les fiches de votre application les unes en fonction des autres, au fur et à mesure que vous les concevez. Lorsque vous déplacez la fiche dans la fenêtre d'aperçu, les coordonnées x,y du coin supérieur gauche de la fiche sont affichées. Par exemple, "0,0" représente le coin supérieur gauche de l'écran.

===Concepteur HTML===

Utilisez le '''concepteur HTML''' pour visualiser et modifier les fiches Web ou les pages HTML. Ce concepteur comporte un '''Editeur de balise''' pour modifier les balises HTML avec la représentation visuelle de la fiche ou de la page. Vous pouvez aussi utiliser '''l'inspecteur d'objets''' pour modifier les propriétés des éléments visibles de la page HTML et afficher les propriétés de la balise HTML en cours dans '''l'éditeur de balise'''. Une boîte à options située au-dessus de '''l'éditeur de balise''' vous permet d'afficher et de modifier les balises SCRIPT.

Pour créer un nouveau fichier HTML, choisissez {{Menu|Fichier > Nouveau > Autre > Web > Page HTML}}.
}}

===Directives de conception===

Si vous créez un composant pour une fiche, vous pouvez enregistrer un type d'objet, puis indiquer différents points sur ses limites, ou proches d'elles, qui constitueront des points "d'alignement". Ces points d'alignement sont des traits verticaux ou horizontaux qui traversent les limites d'un contrôle virtuel.

Quand les points d'alignement sont en place, vous pouvez fournir les informations sur les directives de l'UI de façon à ce que chaque composant respecte les prescriptions s'appliquant, par exemple, à la distance entre les contrôles, aux raccourcis, aux libellés prenant la focalisation, à l'ordre de tabulation, au nombre maximal d'éléments (zones de liste, menus), et ainsi de suite. De cette façon, le '''Concepteur de fiches''' peut assister le développeur de code dans l'adhésion aux directives établies sur l'UI.

Si l'option '''Accrocher à la grille''' est activée (sur {{Menu|Outils > Options > Interface utilisateur > [[Options du Concepteur de fiches|Concepteur de fiches]]}}), ainsi que '''Utiliser les directives du concepteur''', les directives du concepteur sont prioritaires. Cela signifie que si un point de la grille se trouve dans la tolérance du nouvel emplacement et qu'une directive se trouve également dans le voisinage, le contrôle respecte la directive et non la position sur la grille, même si la directive ne coïncide pas avec la position sur la grille. La tolérance d'alignement est déterminée par la taille de la grille. Même si les options '''Accrocher à la grille''' et '''Afficher la grille''' sont désactivées, le Concepteur détermine la tolérance en fonction de la taille de la grille.

==Palette d'outils==

La '''[[Palette d'outils|Palette d'outils]]''', située sur la colonne de droite, contient des éléments qui vous permettent de développer votre application. Les éléments affichés dépendent de la vue en cours. Par exemple, si vous affichez une fiche sur le concepteur, la '''palette d'outils''' affiche les composants appropriés à cette fiche. Double-cliquez sur un contrôle pour l'ajouter à votre fiche. Vous pouvez aussi le faire glisser vers une position désirée de la fiche. Si vous visualisez du code dans '''l'éditeur de code''', la '''palette d'outils''' affiche des segments de code que vous pouvez ajouter à votre application.

===Composants personnalisés===

Outre les composants qui sont installés avec {{Variables|Product}}, vous pouvez ajouter des composants personnalisés ou tiers à '''la palette d'outils''' et les enregistrer dans leur propre catégorie.

===Templates de composants===

Vous pouvez créer des templates composés d'un ou de plusieurs composants. Après avoir organisé les composants sur une fiche, défini leurs propriétés et écrit du code pour eux, vous pouvez les enregistrer sous la forme d'un template de composant. Par la suite, en sélectionnant le template dans '''la palette d'outils''', vous pouvez placer les composants préconfigurés sur une fiche en une seule étape ; toutes les propriétés et tout le code de gestion d'événement associés sont simultanément ajoutés à votre projet. Vous pouvez repositionner les composants indépendamment les uns des autres, réinitialiser leurs propriétés, et créer ou modifier des gestionnaires d'événements comme si vous aviez positionné chaque composant séparément.
{{f|componenttoolbar|2=

==Barre d'outils des composants==

La '''[[Barre d'outils des composants|Barre d'outils des composants]]''' contient toutes les catégories et tous les composants qui apparaissent sur la '''palette d'outils''' régulière (Standard, Accès aux données, et ainsi de suite). Toutefois, la '''barre d'outils des composants''' affiche les catégories de composants sous la forme d'un ensemble d'onglets situé sur la barre d'outils au sommet de la fenêtre de l'EDI, similaire à {{Delphi|7}} {{Version|7}} et {{CBuilder|6}} {{Version|6}}. Cliquez sur un onglet de la barre d'outils des composants pour afficher les icônes des composants de cette catégorie. Cliquez ensuite sur une icône pour sélectionner un composant.

Quand la '''barre d'outils des composants''' est activée, la '''palette d'outils''' est aussi disponible, et vous pouvez utiliser la '''barre d'outils des composants''' ou la '''palette d'outils''' pour ajouter des composants à votre application. Voir [[Activation de la barre d'outils des composants|Activation de la barre d'outils des composants]].

Pour de plus amples informations sur les différentes barres d'outils disponibles dans l'EDI, voir '''[[Barres d'outils|Barres d'outils]]'''.
}}

==Inspecteur d'objets==

'''
[[Inspecteur d'objets|L'inspecteur d'objets]]''', situé sur la gauche, vous permet de définir les propriétés de conception et de créer des gestionnaires d'événements pour vos composants. Il fournit la connexion entre l'apparence visuelle de votre application et le code qui lui permet de fonctionner. '''L'inspecteur d'objets''' contient deux onglets : '''Propriétés''' et '''Evénements'''.

Utilisez l'onglet '''Propriétés''' pour modifier les attributs physiques des composants. Selon votre sélection, certaines catégories d'options vous permettent d'entrer une valeur dans une zone de texte, alors que d'autres attendent que vous sélectionniez une valeur dans une liste déroulante. Pour les opérations booléennes, vous passez de True à False, et vice-versa. Après avoir modifié les attributs physiques de vos composants, vous créez des gestionnaires d'événements qui gèrent les composants.

Utilisez l'onglet '''Evénements''' pour spécifier les événements d'un objet spécifique que vous sélectionnez. S'il existe un gestionnaire d'événement, utilisez la liste déroulante pour le sélectionner. Par défaut, certaines options de '''l'inspecteur d'objets''' sont repliées. Pour développer les options, cliquez sur le signe plus (+) en regard de la catégorie.

Certains composants non visuels, comme les fournisseurs de données Borland offrent un accès rapide à des éditeurs comme '''l'éditeur de connexion''' et '''l'éditeur de texte de commande'''. Vous pouvez accéder à ces éditeurs dans la zone '''Verbe du concepteur''' en bas de '''l'inspecteur d'objets'''. Pour ouvrir les éditeurs, placez votre curseur sur le nom de l'éditeur jusqu'à ce que le curseur prenne la forme d'une main et l'éditeur se change en un lien. Vous pouvez aussi cliquer avec le bouton droit sur le composant non visuel et défiler jusqu'à l'éditeur associé et le sélectionner. Sachez que les composants non visuels n'ont pas tous d'éditeur associé. En plus des éditeurs, cette zone peut aussi afficher des hyperliens pour montrer des éditeurs de composants personnalisés, lancer une page web et afficher des boîtes de dialogue.

==Référentiel d'objets==

Pour simplifier le développement, {{Variables|Product}} propose des templates prédéfinis, des fiches et d'autres éléments auxquels vous avez accès et que vous pouvez utiliser dans vos applications.

===Contenu du référentiel d'objets===

Le '''[[Référentiel d'objets|Référentiel d'objets]]''' contient des éléments qui correspondent aux types d'applications que vous pouvez développer. Il contient des templates, des fiches et bien d'autres éléments. Vous pouvez créer des projets tels qu'une bibliothèque de classes, une bibliothèque de contrôles, des applications console et autres en accédant aux templates disponibles.

Pour ouvrir le '''référentiel d'objets''', choisissez <font color="#598527">'''Fichier > Nouveau > Autre'''</font>. La boîte de dialogue '''Nouveaux éléments''' affiche le contenu du '''référentiel d’objets'''. Vous pouvez aussi modifier ou retirer des objets existants du '''référentiel d'objets''' en cliquant avec le bouton droit dans le '''référentiel d'objets''' afin d'afficher les options d'édition.

===Templates du référentiel d'objets===

Vous pouvez ajouter vos propres objets au '''référentiel d'objets''' en tant que templates que vous réutilisez ou partagez avec d'autres développeurs. La réutilisation d'objets vous permet de concevoir des familles d'applications ayant une interface utilisateur et des fonctionnalités communes, afin de réduire les temps de développement et d'améliorer la qualité.

Vous pouvez ajouter dans le '''référentiel d'objets''' un projet de démarrage, une démo, un template ou tout autre fichier utile et le rendre accessible depuis le menu Nouveau. Choisissez <font color="#598527">'''Projet > Ajouter au référentiel'''</font>. Sélectionnez votre fichier. Ensuite, lorsque vous sélectionnez la commande <font color="#598527">'''Fichier > Nouveau'''</font>, vous pouvez choisir le fichier que vous venez d'ajouter et en utiliser un nouvel exemplaire.

{{Variables|Product}} vous permet de créer plusieurs bibliothèques de templates personnalisées servant de base à la création de futurs projets. Les bibliothèques de templates vous permettent de définir l'apparence des projets et d'ajouter de nouveaux types de projets dans le '''référentiel d'objets'''.

==Gestionnaire de projets==

Un '''projet''' est constitué de plusieurs fichiers d'application. La '''[[Fenêtre Projets|Fenêtre Projets]]''', située dans la colonne supérieure droite, permet de visualiser et d'organiser les fichiers de votre projet, comme les fiches, les exécutables, les assemblages, les objets et les fichiers bibliothèque. Dans le '''Gestionnaire de projets''', vous pouvez ajouter, retirer et renommer des fichiers en utilisant la barre d'outils ou le menu contextuel. Vous pouvez même appeler la boîte de dialogue Options de projet depuis le menu contextuel du '''Gestionnaire de projets'''.

===Groupes de projets===

Vous pouvez combiner des projets associés pour former un '''groupe de projets'''. Pour ce faire, cliquez avec le bouton droit sur le noeud groupe de projets par défaut ([[File:Project Group.png]]) dans le '''Gestionnaire de projets''' et sélectionnez '''[[Ajouter un nouveau projet|Ajouter un nouveau projet]]''' ou '''Ajouter un projet existant'''. La liaison de plusieurs projets en un groupe de projets vous permet de compiler le groupe de projets entier en une seule fois. Mais vous pouvez aussi compiler tout projet unique en cliquant avec le bouton droit sur un noeud de projet et en sélectionnant une des commandes de compilation ou de construction sur le menu contextuel.

Après la création délibérée d'un groupe de projets, vous êtes invité à enregistrer le fichier <code>.groupproj</code> quand vous quittez l'EDI ou entrez une commande d'enregistrement pour un des projets inclus. Vous pouvez aussi enregistrer explicitement un groupe de projets en utilisant les commandes du menu contextuel.

==Explorateur de données==

'''
[[Explorateur de données|L'explorateur de données]]''' permet de parcourir des objets de schéma spécifiques au serveur de base de données, notamment les tables, les champs, les définitions de procédures stockées, les déclencheurs et les index. Les menus contextuels vous permettent de créer et de gérer les connexions aux bases de données. Vous pouvez aussi faire glisser et déposer des données depuis une source de données vers la plupart des fiches pour construire rapidement votre application de base de données.

==Vue Structure==

La '''[[Vue Structure|Vue Structure]]''' présente la hiérarchie du code source ou le langage HTML affiché dans '''l'éditeur de code''', ou les composants affichés sur le concepteur. Si la vue affiche la structure du code source ou le langage HTML, vous pouvez double-cliquer sur un élément pour accéder à sa déclaration ou à son emplacement dans '''l'éditeur de code'''. Si la vue affiche des composants, vous pouvez double-cliquer sur un composant pour le sélectionner sur la fiche.

Si votre code contient des erreurs de syntaxe, elles s'affichent dans le dossier '''Erreurs''' de la vue '''Structure'''. Double-cliquez sur une erreur pour localiser sa source dans '''l'éditeur de code'''.

Vous pouvez contrôler le contenu et l'aspect de la '''vue Structure''' en choisissant {{Menu| Outils > Options > Interface utilisateur > [[Structure|Structure]]}}, puis en modifiant les paramètres.

==[[Audit de code intelligent|Fenêtre de chat IA]]==

La fenêtre de chat IA est une fiche ancrable de l'EDI, qui fonctionne comme n'importe quelle fenêtre de chat LLM. Vous pouvez taper une requête, choisir un moteur et attendre la réponse.

Pour pouvoir utiliser cette fonctionnalité, vous devez toutefois l'activer dans l'option [[Options relatives à l'audit de code intelligent|Audit de code intelligent]].

==Gestionnaire de l'historique==

Le '''[[Gestionnaire de l'historique|Gestionnaire de l'historique]]''', situé dans le volet central, vous permet de voir et de comparer les versions d'un fichier, y compris les diverses versions sauvegardées, les modifications enregistrées localement et le tampon mémoire des modifications non enregistrées d'un fichier actif. Si le fichier en cours est sous contrôle de version, tous les types des révisions sont disponibles dans le '''gestionnaire de l'historique'''.

'''
[[Intégration de Subversion dans l'EDI|L'intégration de Subversion dans l'EDI]]''' est implémentée sur le '''gestionnaire de l'historique''', qui affiche les informations Subversion chaque fois qu'elles sont disponibles dans le système de fichiers.

Le '''gestionnaire de l'historique''' se trouve à droite de l'onglet '''Code''' et contient les pages à onglets suivantes :

*La page '''Contenu''' affiche les versions actuelle et précédente du fichier.
*La page '''Diff''' affiche les différences entre les versions sélectionnées du fichier.
*La page '''Info''' affiche tous les libellés et commentaires associés au fichier actif.

Vous pouvez utiliser la barre d'outils du '''gestionnaire de l'historique''' pour actualiser les informations de révision, rétablir une version sélectionnée à la version la plus actuelle et synchroniser le défilement entre les visualiseurs source de la page '''Contenu''' ou '''Diff''', et '''l'éditeur de code''', et pour la navigation de fenêtre (comme Aller à la différence suivante).

==Editeur de code==

'''
[[Editeur de code|L'éditeur de code]]''', situé dans le volet central, propose un moyen pratique de visualiser et de modifier le code source. C'est un éditeur UTF8 complet et personnalisable qui comprend entre autres les sauvegardes automatiques, l'audit de code, la mise en surbrillance syntaxique, de multiples capacités d'annulation, l'aide contextuelle, les templates dynamiques, la saisie semi-automatique de blocs (achèvement de bloc), la recherche de classe, la recherche d'unités et l'importation d'un espace de nommage.

==Débogueur==

Les débogueurs intégrés vous permettent de trouver et de corriger les erreurs d'exécution et de logique dans votre application {{Variables|Product}}. En utilisant les débogueurs, vous pouvez parcourir le code pas à pas, définir des points d'arrêt et de suivi et inspecter ou modifier les valeurs du programme. Quand vous déboguez votre application, les [[Fenêtres de débogage - Index|fenêtres de débogage]] sont disponibles pour vous aider à gérer la session de débogage et vous donnent des informations sur l'état de votre application.

==Voir aussi==

*[[Aperçu et page d'accueil|Aperçu et page d'accueil]]
*[[Référence EDI et utilitaires|Référence EDI et utilitaires]]
*[[Démarrage d'un projet - Présentation|Démarrage d'un projet - Présentation]]
*[[Enregistrement des dispositions du bureau|Enregistrement des dispositions du bureau]]
*[[Concepteur de fiches|Concepteur de fiches]]
*[[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]]
*[[Editeur de code|Editeur de code]]
*[[Personnalisation de l'éditeur de code|Personnalisation de l'éditeur de code]]
*[[Fractionnement de l'éditeur|Fractionnement de l'éditeur]]
*[[Débogage des applications - Index|Débogage des applications]]
*[[Utilisation du Gestionnaire de l'historique|Utilisation du Gestionnaire de l'historique]]
*[[Rubriques de l'explorateur de classes Delphi|Rubriques de l'explorateur de classes Delphi]]
*[[Rubriques de l'explorateur de classes C++|Rubriques de l'explorateur de classes C++]]

[[Category:Prise en main]]
[[Category:AMMigrate]]

Options de la cible

Yukikoi — Fri, 09 Oct 2026 18:13:03 GMT

Yukikoi a importé Options de la cible par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Boîte de dialogue Options de projet}}

Ce jeu d'options vous permet d'appliquer le jeu d'options de projet défini sur la page en cours à diverses combinaisons de [[Plates-formes cible prises en charge|plate-forme cible]] et configurations de construction (ou à toutes les plates-formes, ou toutes les configurations).

Les options de la cible occupent la ligne supérieure de toutes les pages, associées à la construction et à la compilation, de la boîte de dialogue '''[[Boîte de dialogue Options de projet|Options de projet]]''', comme {{Menu | Projet > Options > [[Compilateur Delphi|Compilateur Delphi]]}}.

{| border="1" frame="hsides" rules="rows"
|-
!'''Options de la cible'''
!'''Description'''
|- valign="top"
|
Cible
|
La '''Cible''' est le nom de la configuration de construction associée aux options définies sur cette page. Le champ Cible affiche la configuration et la plate-forme cible associée, par exemple '''Configuration Débogage - Plate-forme Windows 32 bits''' (la configuration cible par défaut pour les applications Windows 32 bits).
Configurations intégrées que vous pouvez choisir comme cible :
*'''Toutes les configurations'''
*'''Débogage'''
*'''Release'''

Toutes les configurations de construction que vous avez créées sont listées en plus des configurations intégrées. La configuration de construction par défaut initiale est '''Débogage'''.
Les plates-formes cible associées à ces configurations de construction sont celles qui existent sur la '''[[Fenêtre Projets|Fenêtre Projets]]''', sous le noeud [[Présentation des plates-formes cible|Plates-formes cible]] de votre noeud de projet.
:{{Note| Chaque projet doit inclure au moins une plate-forme cible.}}

'''Exemples'''
La sélection d'une '''Cible''' applique les options de la page en cours à la configuration sélectionnée sur la plate-forme sélectionnée. Par exemple, voici les résultats quand vous sélectionnez les valeurs suivantes dans la liste déroulante '''Cible''' :
*'''Toutes les configurations'''
**Applique les options de la page à chaque combinaison de plate-forme et de configuration.
**'''Toutes les configurations - Toutes les plates-formes''' apparaît dans la boîte de dialogue.
*'''Configuration Release'''
**Applique les options de la page à la configuration '''Release''' sur chaque combinaison de plate-forme et de configuration.
**'''Configuration Débogage - Toutes les plates-formes''' apparaît dans la boîte de dialogue.
*'''Configuration Débogage > Plate-forme Windows 32 bits'''
**Applique les options de la page à la configuration '''Débogage''' sur la plate-forme '''Windows 32 bits'''.
**'''Configuration Débogage - Plate-forme Windows 32 bits''' apparaît dans la boîte de dialogue.

Pour plus d'informations sur les configurations de construction, voir [[Présentation des configurations de construction|Présentation des configurations de construction]].
|- valign="top"
|
Appliquer...
|
Affiche la boîte de dialogue '''[[Appliquer le jeu d'options|Appliquer le jeu d'options]]''' afin d'appliquer les options d'un jeu d'options nommé existant (fichier <code>.optset</code>) à la configuration en cours.
Pour plus d'informations sur les jeux d'options, voir [[Présentation des jeux d'options|Présentation des jeux d'options]].
|- valign="top"
|
Enregistrer...
|
Affiche la boîte de dialogue '''[[Commandes Enregistrer|Enregistrer]]''', vous permettant d'enregistrer les paramètres '''Options de projet''' en cours sous un fichier jeu d'options (fichier <code>.optset</code>).
Pour plus d'informations sur les jeux d'options, voir [[Présentation des jeux d'options|Présentation des jeux d'options]].
|}

Pour changer la valeur d'une option sur la [[Boîte de dialogue Options de projet|boîte de dialogue Options de projet]], cliquez sur le champ valeur, puis entrez une valeur ou cliquez sur la [[Image:ProjectOptionsDownArrow2.jpg|flèche vers le bas]] affichée pour effectuer une sélection parmi les choix disponibles.

==Voir aussi==

*[[Boîte de dialogue Options de projet|Boîte de dialogue Options de projet]]
*[[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]]
*[[Activation et configuration de la plate-forme cible|Ajout d'une plate-forme cible à votre projet]]

[[Category:Référence EDI]]
[[Category:XE2]]
[[Category:AMMigrate]]

Sprintf, swprintf

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Sprintf, swprintf par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Stdio.h - Index|stdio.h}}
{{DISPLAYTITLE:sprintf, swprintf}}<ideTag id="sprintf"></ideTag>
<ideTag id="swprintf"></ideTag>
'''Fichier d'en-tête'''

stdio.h

'''Catégorie'''

Routines de mémoire et de manipulation de chaînes

'''Prototype'''

<span class="codeInline">int sprintf(char *buffer, const char *format[, argument, ...]);</span>

<span class="codeInline">int swprintf(wchar_t *buffer, size_t bufsz, const wchar_t *format[, argument, ...]);</span>

'''Description'''

Ecrit la sortie formatée dans une chaîne.

{{Note| Pour plus de détails sur les spécificateurs de format, voir [[Printf, wprintf|printf]].}}

[[Sprintf, swprintf|sprintf]] accepte une suite d'arguments, applique à chacun un spécificateur de format contenu dans la chaîne de format pointée par format, et envoie les données formatées dans une chaîne.

[[Sprintf, swprintf|sprintf]] applique le premier spécificateur de format au premier argument, le second au second, etc. Il doit y avoir autant de spécificateurs de format que d'arguments.

'''Valeur renvoyée'''

En cas de réussite, [[Sprintf, swprintf|sprintf]] renvoie le nombre d'octets. La valeur renvoyée n'inclut pas l'octet nul terminal dans le décompte.

En cas d'erreur, [[Sprintf, swprintf|sprintf]] renvoie EOF.

'''Exemple'''

#include <stdio.h>
#include <math.h>
int main(void)
{
char buffer[80];
sprintf(buffer, "An approximation of Pi is %f\n", M_PI);
puts(buffer);
return 0;
}

'''Portabilité'''

{| border="1" frame="hsides" rules="rows"
|-
!''' '''
!'''POSIX'''
!'''Win32'''
!'''ANSI C'''
!'''ANSI C++'''
|-
| style="text-align: left; vertical-align: top;" |
sprintf
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
|-
| style="text-align: left; vertical-align: top;" |
swprintf
| style="text-align: left; vertical-align: top;" |
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
|}

==Voir aussi==

*[[Spécificateurs de format dans C/C++|Spécificateurs de format dans C/C++]]
* [[Chaîne de format printf|Chaîne de format printf]]
* [[Spécificateurs de format printf|Spécificateurs de format printf]]
*[[Printf, wprintf|printf, wprintf]]

[[Category:Référence C++]]
[[Category:C++]]
[[Category:AMMigrate]]

Sprintf s, swprintf s

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Sprintf s, swprintf s par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Stdio.h - Index|stdio.h}}
{{DISPLAYTITLE:sprintf_s, swprintf_s}}<ideTag id="sprintf_s"></ideTag>
<ideTag id="swprintf_s"></ideTag>
'''Fichier d'en-tête'''

stdio.h

'''Catégorie'''

Fonctions d'entrée/sortie formatées

'''Prototype'''

<span class="codeInline">int sprintf_s(char * restrict s, rsize_t n, const char * restrict format, ...);</span>

<span class="codeInline">int swprintf_s(wchar_t* restrict buffer, rsize_t bufsz, const wchar_t* restrict format, ... );</span>

'''Description'''

Remplace [[Sprintf, swprintf|sprintf]] tout en renforçant la sécurité.

'''sprintf_s''' est équivalente à '''sprintf''', sauf pour les contraintes d'exécution qui imposent que '''s''' et '''format''' ne soient pas des pointeurs null. D'autres contraintes exigent que chaque spécificateur de format '''%s''' dans '''format''' ait un argument non null et que le spécificateur '''%n''' ne soit pas utilisé dans '''format'''.

Si une violation de contrainte d'exécution se produit et que '''s''' n'est pas un pointeur null, et que '''n''' est supérieur à zéro et inférieur à RSIZE_MAX, la fonction place '\0' dans '''s[0]'''.

A l'inverse de [[Snprintf s, snwprintf s|snprintf_s, snwprintf_s]], dans le cas où '''n''' est plus grand que le tableau pointé par '''s''', elle déclenche une exception de contrainte d'exécution.

'''Valeur renvoyée'''

En cas de réussite, '''sprintf_s''' renvoie le nombre de caractères, sans inclure le '\0' terminal.
En cas d'erreur de codage, '''sprintf_s''' renvoie une valeur négative. Pour les autres types d'erreurs, zéro est renvoyé.

'''Exemple'''

#include <stdio.h>
#include <math.h>
int main(void)
{
char buffer[80];
sprintf_s(buffer, 40, "An approximation of Pi is %f\n", M_PI);
puts(buffer);
return 0;
}

'''Portabilité'''

{| border="1" frame="hsides" rules="rows"
|-
!
! '''POSIX'''
!'''Win32'''
!'''ANSI C'''
!'''ANSI C++'''
|-
| style="text-align: left; vertical-align: top;" |
sprintf_s
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
|-
| style="text-align: left; vertical-align: top;" |
swprintf_s
| style="text-align: left; vertical-align: top;" |
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
| style="text-align: left; vertical-align: top;" |
+
|}

==Voir aussi==

*[[Spécificateurs de format dans C/C++|Spécificateurs de format dans C/C++]]
* [[Bibliothèque C sécurisante|Bibliothèque C sécurisante]]

[[Category:Référence C++]]
[[Category:C++]]
[[Category:AMMigrate]]

Fractionnement de l'éditeur

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Fractionnement de l'éditeur par téléversement de fichier (1 version) LOC-23451

Nouvelle page

La vue [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] permet d’utiliser plusieurs éditeurs côte à côte, les uns au-dessus des autres, ou de façon combinée, le tout dans une même fenêtre. Cela inclut la possibilité de faire glisser des ensembles d'onglets vers des fenêtres flottantes, puis de les replacer dans l'EDI.
Elle permet aussi d'avoir plusieurs dispositions personnalisées et offre diverses possibilités de manipulation : disposition simple en deux colonnes, disposition sur plusieurs lignes, ou une configuration particulièrement adaptée à votre flux de travail.
Vous pouvez travailler en ayant plusieurs onglets ouverts, et ouvrir la même unité dans chacun de ces onglets. Vous pouvez aussi avoir plusieurs onglets ouverts : l'un avec le concepteur de fiche et plusieurs autres avec le code de l'unité correspondante. L'onglet contenant le concepteur de fiche peut aussi être déplacé.
Il n'y a '''aucune limite''' quant au nombre de vues fractionnées, que ce soit horizontalement ou verticalement.

===Utilisation du fractionnement de l'éditeur===

Vous pouvez accéder à la vue Fractionnement de l'éditeur en cliquant avec le bouton droit sur un onglet et en choisissant '''Fractionner >''' ou '''Déplacer >'''. Le fractionnement crée une nouvelle version de l'onglet sélectionné, et le déplacement provoque son ouverture à l'endroit sélectionné dans l'EDI.

[[File:Using-spliteditor.png|=link|400px|border]]

Les raccourcis suivants peuvent être utilisés pour les deux options :

*'''Fractionner en haut :''' Alt+Maj+T
*'''Fractionner en bas :''' Alt+Maj+B
*'''Fractionner à droite :''' Alt+Maj+R
*'''Fractionner à gauche :''' Alt+Maj+L
*'''Déplacer en haut :''' Ctrl+Alt+Maj+T
*'''Déplacer à gauche :''' Ctrl+Alt+Maj+L
*'''Déplacer à droite :''' Ctrl+Alt+Maj+R
*'''Déplacer en bas :''' Ctrl+Alt+Maj+B

Alternativement, vous pouvez utiliser [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] en faisant glisser un fichier de la vue Projets dans un onglet de l'éditeur. Vous pouvez aussi effectuer un clic droit sur le fichier du projet, puis sélectionner l'option '''Ouvrir dans''' et choisir l'onglet de l'éditeur dans lequel vous souhaitez ouvrir le fichier.

Lorsque deux onglets sont dans une fenêtre, chacun a une barre de titre.

Le fractionnement de l'éditeur vous permet de :

*Faire glisser un onglet de l'éditeur, ou un ensemble d'onglets, en faisant glisser la barre de titre et en l'ancrant sur n'importe quel côté de la fenêtre de l'EDI.
*Le faire glisser et l'ancrer sur n'importe côté de l'éditeur (gauche, droit, haut, bas).
*Le fusionner avec un ensemble d'onglets en le faisant glisser au centre d'un éditeur existant, y compris une fenêtre flottante d'onglets.
*Le faire glisser en dehors de sa propre fenêtre (soit un seul onglet ou un ensemble d'onglets).

La plupart des opérations peuvent être réalisées sur des onglets individuels. Il peut s'agir par exemple de déplacer un onglet entre des ensembles d'onglets ancrés en faisant glisser l'onglet individuel d'un emplacement à un autre.

Chaque ensemble d'onglets peut être déplacé à l'extérieur de sa propre fenêtre. Faites glisser la barre de titre pour le déplacer.
{{Tip| Vous pouvez appuyer sur Ctrl tout en faisant glisser l'ensemble d'onglets pour vous assurer qu'il ne s'ancre pas.}}

De la même façon, chaque fenêtre peut être ancrée à côté d'un autre ensemble d'onglets. Pour cela, vous devez faire glisser la barre de titre.

{{Note|La plupart des éditeurs/groupes disparaissent de la vue lorsqu'ils sont fermés. Toutefois, la fermeture du premier éditeur (celui qui était auparavant l'éditeur de la fenêtre principale) avec le bouton ‘X’ provoque la fermeture de tous les onglets qu'il contient. L'espace qu'il occupait reste ouvert, car l'éditeur original ne peut pas être fermé. Cela n'a aucune incidence tant que les groupes d'onglets ne sont pas fermés. Il n'y a aucun impact visible lorsque vous créez, déplacez ou ancrez les onglets dans vos tâches.}}

[[File:Split Editor Example.png|800px|]]

''C'est l'une des nombreuses façons de configurer la vue Fractionnement de l'éditeur. Elle comporte une fenêtre d'édition sur la gauche, deux à droite, et les volets sont masqués mais apparaissent lorsqu'ils sont survolés par la souris.''

===Concepteur et code===

Les vues Fractionnement de l'éditeur permettent de modifier un même fichier dans deux fenêtres d'édition affichées côte à côte, chacune affichant le même contenu de fichier. Lorsque vous tapez dans l'une et que vous faites défiler le texte jusqu'à un emplacement, le texte apparaît dans l'autre fenêtre. Vous pouvez faire défiler les deux fenêtres indépendamment l'une de l'autre, ce qui permet de modifier le fichier à plusieurs endroits.
Vous pouvez ainsi ouvrir un même fichier dans autant d'onglets que vous le souhaitez.
{{Note|Gardez toujours à l'esprit qu'il n'y a qu'un seul fichier (module ou tampon de fichier en termes internes) affiché dans plusieurs vues. Ainsi, toute modification effectuée dans l'une de ces vues sera répercutée dans les autres vues (il ne s'agit pas de copier ou de dupliquer une modification). <br />
Autrement dit, toute modification de fichier depuis une fenêtre d'édition concerne le fichier lui-même et pas la fenêtre. Cette modification sera répercutée dans les autres vues. }}

===Conseils et astuces===

*'''Enregistrez''' la configuration des éditeurs en tant que disposition du bureau. Sinon, vous risquez de passer beaucoup de temps à définir une présentation qui ne sera pas sauvegardée.

{{Notes|

*Lorsque la disposition de bureau est modifiée, la configuration change également (par ex. lorsque l'EDI commence le débogage et passe en '''Disposition de débogage'''.
*Lorsque vous changez de disposition, tout groupe d'onglets qui ne trouve pas sa place dans la disposition est détaché et devient une fenêtre flottante.}}
*Activez '''Options''' > '''Enregistrement et récupération''' > '''Enregistrer le bureau du projet lors de la fermeture''' et '''Enregistrer l'état de l'éditeur à la fermeture d'un onglet'''.
*Lorsque vous enregistrez l'état de l'éditeur, vous enregistrez également la position de défilement, les zones réduites ou développées, etc. C'est très pratique lorsque plusieurs fenêtres d'édition du même fichier sont ouvertes. Ainsi, lorsque vous rouvrez votre bureau et rouvrez le projet (ou tout simplement, lorsque vous rouvrez un éditeur précédemment fermé), la nouvelle fenêtre d'édition s'affiche telle qu'elle était au moment de la fermeture.
*Pensez à désancrer les volets ancrables d'ancienne génération. Ils sont réduits sous forme de petit onglet sur un côté de la fenêtre principale. Vous pouvez les rendre visibles à nouveau en cliquant dessus, et ils restent affichés tant qu’ils ont la focalisation. Pour cela, vous devez cliquer sur le bouton d'épinglage dans la barre de titre du volet, à côté du bouton X. Cette fonctionnalité existe depuis de nombreuses années, mais elle n’était vraiment utile que lorsque l’espace à l'écran était limité. Maintenant que plusieurs fenêtres d'édition peuvent être fractionnées et ancrées ensemble, il devient très pratique de pouvoir désépingler les volets latéraux pour libérer de l’espace horizontal.
*Pensez à faire un clic droit sur un onglet '''> Fractionner > A droite''' (ou '''A gauche'''). L'utilisation de plusieurs colonnes est certainement la configuration la plus courante pour les vues fractionnées. Plus vous utiliserez cette fonctionnalité, plus vous constaterez son utilité.

==Voir aussi==

*[[Présentation de l'EDI|Présentation de l'EDI]]
*[[Aperçu et page d'accueil|Aperçu et page d'accueil]]

Audit de code intelligent

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Audit de code intelligent par téléversement de fichier (1 version) LOC-23451

Nouvelle page

[[Audit de code intelligent|Smart CodeInsight]] est une architecture ouverte qui vous permet d'utiliser vos moteurs d'IA préférés. En plus des fonctionnalités déjà présentes, {{Product}} vous propose également une intégration de l'interface utilisateur personnalisable :

* Moteur d'IA de base et ToolsAPI.
*Intégration de l'EDI :
** [[#Options de configuration|Options de configuration pour les moteurs]].
** [[#Commandes de menu de l'éditeur|Commandes de menu de l'éditeur permettant d'invoquer des opérations IA]].
** [[#Fenêtre de chat IA|Fenêtre de chat IA]].
* Prise en charge des fournisseurs LLM en ligne et hors ligne tels que :
** OpenAI, Gemini et Claude (en ligne).
** Ollama (hors ligne).

:
::{{Tip| Ollama est distribué en tant que produit open source sous licence MIT. Les modèles individuels que vous êtes susceptible d'utiliser avec Ollama ont leurs propres licences. La politique d'utilisation "Codellama Acceptable Use Policy" est disponible sur cette page.}}
::{{Note| Pour les adeptes de ToolsAPI, {{Product}} vous permet de créer votre propre plugin API. Pour plus d'informations, consultez la page [[Create and implement your AI plugin|Créer et implémenter votre plugin IA]].}}

{{Warning|{{Product}} ne fournit pas d'accès à ces moteurs. L'utilisation de ces services d'IA nécessite que l'utilisateur accepte les conditions d'utilisation de chaque éditeur, reçoive une clé API permettant d'entrer dans la configuration de {{Product}}, et paie les frais de licence de la société d'IA concernée.
La seule exception concerne Ollama qui peut être utilisé hors ligne gratuitement et être installé en local ou sur un serveur de votre choix.}}

==Options de configuration==

{{Product}} vous permet de configurer et de contrôler pleinement la confidentialité de différentes façons. Vous pouvez ainsi :

* Désactiver la fonctionnalité IA complète à partir d'un paramètre unique.
* Activer ou désactiver chacun des quatre moteurs.
* Sélectionner le moteur par défaut de chacun des éléments d'interface utilisateur (fenêtre de chat et menu éditeur).

Toutes ces fonctionnalités peuvent être configurées dans la fenêtre Options de l'EDI. Consultez la page [[Options relatives à l'audit de code intelligent|Configuration de l'audit de code intelligent]] pour plus d'informations sur chaque rubrique.

* Les actions suivantes ont aussi été implémentées pour sécuriser le système.
* Les clés API sont stockées dans un format chiffré.
* Vous avez la possibilité d'utiliser un moteur local, hors ligne.

==Commandes du menu Editeur==

Le menu Editeur propose des opérations préconfigurées pour le code sélectionné dans l'éditeur. Le but est d'analyser et d'optimiser une partie du code source de votre application.

Le moteur LLM réagit en renvoyant le résultat dans une fenêtre de l'éditeur sous forme de commentaire après le code analysé.

===Commandes disponibles :===

Voici les commandes disponibles pour l'audit de code intelligent :

[[Image:Smart CodeInsight-Display.png|450x450px|link=]]

* '''Chat IA''' : ouvre la vue [[#Fenêtre de chat IA]].
* '''Trouver des bogues''' : recherche des bogues potentiels dans le code sélectionné.
* '''Expliquer le code''' : explique le code sélectionné.
* '''Ajouter un commentaire''' : ajoute des commentaires au code sélectionné.
* '''Achever le code''' : termine le code sélectionné.
* '''Optimiser le code''' : optimise le code sélectionné.
* '''Ajouter un test unitaire''' : ajoute un test unitaire au code sélectionné.
* '''Convertir en assembleur''' : convertit le code sélectionné en code assembleur.
* '''Convertir en Delphi''' : convertit le code sélectionné en code Delphi (à partir du code C++ ou assembleur).
* '''Convertir en C++Builder''' : convertit le code sélectionné en code C++Builder.
* '''Trouver l'en-tête (IA)''' (dans C++) ou '''Rechercher une unité''' (dans Delphi) : ajoute l'unité manquante aux instructions uses d'une classe sélectionnée ou d'un type de données.
* '''Afficher le résultat dans l'éditeur''' : envoie la sortie dans l'éditeur.
* '''Afficher le résultat dans le Chat''' '''''' : envoie la sortie dans la fenêtre de chat IA au format Markdown.

==Compagnon RAD AI==

RAD Studio introduit "RAD AI Companion" web, un chat et générateur de code spécifiquement entraîné sur du contenu en lien avec RAD Studio. Le compagnon RAD AI s'active depuis l'EDI en sélectionnant {{Menu| Menu Aide > [http://www.embarcadero.com/radaicompanion RAD AI Companion]}}.

==Fenêtre de chat IA==

La fenêtre de chat IA est une fiche ancrable de l'EDI, qui fonctionne comme n'importe quelle fenêtre de chat LLM. Vous pouvez taper une requête, choisir un moteur (ou utiliser le moteur par défaut) et attendre la réponse. Voici un rapide exemple :

[[Image:ai chat window.png|350px|link=]]

La fenêtre de chat comporte une zone de saisie qui fonctionne comme une ligne de commande. Voici les commandes disponibles :

* <code>chatgpt> + Entrée</code> : active ChatGpt comme moteur d'IA actif (si celui-ci a été activé).
* <code>gemini> + Entrée</code> : active Gemini comme moteur d'IA actif (si celui-ci a été activé).
* <code>claude> + Entrée</code> : active Claude comme moteur d'IA actif (si celui-ci a été activé).
* <code>ollama> + Entrée</code> : active Ollama comme moteur d'IA actif (si celui-ci a été activé).
* <code>clear> + Entrée</code> : efface la zone de réponse.
* <code>stop> + Entrée</code> : arrête la génération de la réponse (équivalent à un clic sur le bouton Stop).
* <code>Ctrl + Entrée</code> : commence à générer la réponse (équivalent à un clic sur le bouton Start).

En plus des requêtes standard, vous pouvez sélectionner un snippet de code spécifique dans la fenêtre de code et poser une '''nouvelle question''' ou '''demander une explication''' en utilisant l'une des commandes suivantes :

[[Image:ai smartchat.png|450px|link=]]

*$COL : correspond au '''numéro de colonne''' sur lequel le curseur est placé dans la fenêtre éditeur de code active.
*$ROW : correspond au '''numéro de ligne''' sur lequel le curseur est placé dans la fenêtre éditeur de code active.
*$CURTOKEN : correspond au '''mot''' sur lequel le curseur est placé dans la fenêtre éditeur de code active. Cette commande peut être utile pour faire référence à une variable, une méthode ou un identificateur situé à l'emplacement du curseur.
*$EDNAME : correspond au '''nom de fichier complet''' de la fenêtre éditeur de code active. Cette commande peut être très utile si vous avez besoin du nom du fichier en cours avec son chemin d'accès.
*$SELECTION : fournit des explications sur le code sélectionné dans l'éditeur actif.
*$UNIT : fournit des explications sur le code de l'unité.

Consultez la page [[Macros de transfert|Macros de transfert]] pour plus d'informations et d'exemples.

===Voir aussi===

* [[Options relatives à l'audit de code intelligent|Options relatives à l'audit de code intelligent]]
* [[Configuration d'Ollama pour l'audit de code intelligent|Configuration d'Ollama]]
* [[Create and implement your AI plugin|Créer et implémenter votre plugin IA]]

Options relatives à l'audit de code intelligent

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Options relatives à l'audit de code intelligent par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Options de l'EDI}}
{{Menu| Outils > Options > EDI > [[Audit de code intelligent|Audit de code intelligent]]}}

Vous pouvez configurer l'intégration de '''l'audit de code intelligent''' dans la partie Audit de code intelligent de la fenêtre Options des outils, comme indiqué dans l'image ci-dessous.

[[File:Smart codeinsight options available.png|600px|link=]]

Sur cette fenêtre, vous pouvez configurer l'intégration IA à partir des champs suivants :

*La case à cocher '''Activer le moteur IA''' permet d'activer la fonctionnalité.
*Les zones de liste déroulante '''IA par défaut pour l'éditeur''' et '''IA par défaut pour la fenêtre de Chat''' vous permettent de choisir l'IA disponible pour chacun des éléments.

De plus, dans la section '''Plugins''', vous pouvez configurer chacun des moteurs IA dans son onglet en spécifiant ses propres paramètres de configuration. Vous trouverez ci-dessous les options initiales suggérées pour chacun des moteurs :

{| class="wikitable" style="width:100%"
|-
! style="width:12%" |Configuration
! style="width:22%" |ChatGPT
!Ollama**
! style="width:22%" |Gemini
! style="width:22%" |Claude
|-
|'''BaseURL'''
|<nowiki>https://api.openai.com/v1</nowiki>
|Dépend de l'installation.
Si c'est un "localhost" avec l'option par défaut, l'URL de base est <nowiki>http://localhost:11434/</nowiki>
|<nowiki>https://generativelanguage.</nowiki>{{#tag:wbr|}}<nowiki>googleapis.com/v1beta</nowiki>
|<nowiki>https://api.anthropic.com/v1</nowiki>
|-
|'''APIKey'''
|[https://platform.openai.com/account/api-keys Clé API dans OpenAI]
| style="background-color:#e6e6e6;" |
| [https://console.cloud.google.com/apis/dashboard Clé API dans l'API et les Services Google Cloud]
|[https://console.anthropic.com/settings/keys Clé API dans Anthropic]
|-
|'''Model*'''
|gpt-4
|codellama
|models/gemini-pro
|claude-3-5-sonnet-20240620
|-
|'''Timeout''' (milliseconds)
|30.000
|30.000
|30.000
|30.000
|-
|'''Maxtoken'''
|2048
| style="background-color:#e6e6e6;" |
|2048
|1024
|-
|'''Temperature'''
|0.1
| style="background-color:#e6e6e6;" |
|0.9
| style="background-color:#e6e6e6;" |
|-
| '''TopP'''
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
|1
| style="background-color:#e6e6e6;" |
|-
| '''TopK'''
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
|1
| style="background-color:#e6e6e6;" |
|-
| '''Anthropic Version'''
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
|2023-06-01
|}

Une fois la configuration terminée, vous pouvez utiliser le bouton '''Tester la connexion''' pour tester la configuration sans avoir besoin de lancer le chat.

{{Note| '''(*)''' RAD Studio suggère une liste de modèles disponibles, obtenus depuis le moteur d'IA précédemment configuré. Cette fonctionnalité est disponible pour tous les moteurs d'IA, à l'exception de Claude. }}

{{Attention| '''(**)''' Si vous configurez Ollama, vous pouvez utiliser une image Docker pour l'installer. Pour plus d'informations, consultez la page Configuration d'Ollama pour l'audit de code intelligent}}
{{Tip|Pour rendre le moteur opérationnel, vous devez effectuer les étapes suivantes :

<ol><li>Configurer un moteur (l'un de ceux mentionnés ci-dessus).</li>
<li>Activer la case à cocher '''Activé''' de ce moteur d'IA.</li>
<li>Choisir le moteur pour l'éditeur et pour la fenêtre de chat.}}

===Voir aussi===
* [[Page d'accueil|Page Bienvenue]]
* [[Mise à niveau des projets|Mise à niveau des projets]]
* [[Audit de code intelligent|Audit de code intelligent]]
</li>
</ol>

Barre de défilement

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Barre de défilement par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Options de l'éditeur}}

{{Menu|Outils > Options > Editeur > Barre de défilement}}

Les annotations de la [[Barre de défilement|barre de défilement]] permettent d'avoir une vue globale de votre code source et de suivre facilement des éléments particuliers.

Utilisez cette page pour configurer les annotations.

{| border="1" frame="hsides" rules="rows"
|-
! '''Elément'''
! '''Description'''
|- valign="top"
|
Appliquer les couleurs du thème de l'éditeur à la barre de défilement
|
Permet à la barre de défilement d'utiliser les couleurs du thème de l'EDI
|- valign="top"
|
Activer les annotations de la barre de défilement
|
Active les options d'annotation de la barre de défilement
|- valign="top"
|
Annotations de la barre de défilement
|
{|
|- valign="top"
|
Activé
|
Case à cocher qui active ou désactive toutes les fonctionnalités permettant d'afficher des marques sur la barre de défilement
|- valign="top"
|
Nom
|
Options d'annotation : Audit d'erreur, Parties modifiées, Résultats de la recherche et Signets
|- valign="top"
|
Début (0 – 15)
|
Intervalle de 0 à 15 définissant la position de départ de la barre de défilement
|- valign="top"
|
Largeur (0 – 15)
|
Intervalle de 0 à 15 définissant la largeur de la barre de défilement
|- valign="top"
|
Aperçu
|
Affiche un aperçu de la barre de défilement telle qu'elle sera avec les paramètres de '''début''' et de '''largeur'''
|}
|- valign="top"
|
Cliquez sur la barre de défilement pour accéder à l'emplacement
|
Accède directement à la position voulue en cliquant sur la barre de défilement
|}

==Voir aussi==

* [[Options de l'éditeur|Editeur]]

Packages d'exécution (Options)

Yukikoi — Fri, 09 Oct 2026 18:13:02 GMT

Yukikoi a importé Packages d'exécution (Options) par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Packages (Options)}}<ideTag id="hcORuntimePackages"></ideTag>

<font color="#598527"> '''Projet > Options > Packages > Packages d'exécution''' </font>

Utilisez cette page pour spécifier les packages d'exécution requis par votre projet.

{| border="1" frame="hsides" rules="rows"
|-
! '''Options'''
! '''Description'''
|- valign="top"
|
Cible, Appliquer, Enregistrer
|
Voir [[Options de la cible|Options de la cible]].
|- valign="top"
|
Eléments communs
|
Voir [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]].
|}

{| border="1" frame="hsides" rules="rows"
|-
! '''Elément'''
! '''Description'''
|- valign="top"
|
Lier avec les packages d'exécution
|
Lie dynamiquement les packages d'exécution dans votre projet.
Par défaut = True pour C++, False pour {{Delphi}}.
|- valign="top"
|
Packages d'exécution <br />'''({{Delphi}})'''
Bibliothèques d'importation des packages d'exécution <br />'''(C++)'''
|
Détermine les packages d'exécution à utiliser quand le fichier exécutable est créé. Pour visualiser et modifier la liste des packages d'exécution, cliquez sur le bouton [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]]. (Assurez-vous que le champ [[Options de la cible|Configuration de la cible]] est défini sur la configuration de construction dont la liste est héritée.)
La boîte de dialogue affiche des listes supplémentaires de packages d'exécution qui sont associées à différentes combinaisons de configuration et de plate-forme, telles que ces valeurs par défaut :<ul><li> Pour {{Delphi}} : <br /><source>
Value from "Debug configuration - All platforms"
Value from "All configurations - 32-bit Windows platform"
Value from "All configurations - All platforms"</source></li>
<li> Pour C++ : <br /><source>
Value from "Debug configuration - All platforms"
Value from "All configurations - 64-bit Windows (Modern) platform"
Value from "All configurations - All platforms"</source></li>
</ul>

Au fur et à mesure que vous installez ou désinstallez des packages, la liste des packages d'exécution est mise à jour. Le produit ajoute automatiquement les packages d'exécution qui sont requis par les packages de conception installés.
|- valign="top"
|

Bouton [[Image:ProjectOptionsEllipsis.jpg|Points de suspension]]
|
Affiche la boîte de dialogue '''Packages d'exécution''', vous permettant d'ajouter, de remplacer ou de supprimer des packages d'exécution. Cette boîte de dialogue est une [[Boîte de dialogue liste-ordonnée|boîte de dialogue <liste ordonnée>]].
|}

==Voir aussi==

* [[Packages d'exécution|Packages d'exécution]]
* [[Choix des packages d'exécution à utiliser|Choix des packages d'exécution à utiliser]]
* [[Chargement des packages dans une application|Chargement des packages dans une application]]

[[Category:Référence RAD Studio]]

Présentation de RAD Server

Yukikoi — Fri, 09 Oct 2026 18:13:01 GMT

Yukikoi a importé Présentation de RAD Server par téléversement de fichier (1 version) LOC-23451

Nouvelle page

==Qu'est-ce que RAD Server ?==

RAD Server est une application clés en main qui permet de construire et déployer des services basés sur des applications. RAD Server permet aux développeurs de construire rapidement de nouveaux back-ends ou de migrer des logiques métier client/serveur C++ ou Delphi vers des architectures basées sur des services modernes, ouverts, sans états, sécurisés et évolutifs.

La facilité de développement, de déploiement et d'utilisation de RAD Server en fait la solution idéale pour les éditeurs indépendants (ISV) et OEM qui conçoivent des solutions destinées à être redéployées. RAD Server vous permet d'utiliser votre code existant et de le convertir en points de terminaison de l'API REST.

===RAD Server offre de nombreuses fonctionnalités :===

*Développement multi-niveaux (multi-tier) simplifié : les intégrations fournissent une connectivité prête à l'emploi avec les serveurs, les applications et les services externes.
*Construisez rapidement vos fiches UX pour les plates-formes de bureau et mobiles dans RAD Studio, Delphi ou C++Builder.
*Gérez vos API et utilisateurs, et analysez l'utilisation et l'activité API via le portail de gestion d'applications RAD Server.
*Hébergez RAD Server sur un serveur Windows privé "on prem" ou sur hôte dans le cloud via Amazon, Rackspace ou Azure Clouds.
*Déployez votre code Delphi et C++ sur RAD Server en créant des points de terminaison API REST/JSON automatiques pour vos clients.
*Connectez RAD Server à vos bases de données d'entreprise, services cloud et périphériques IoT pour étendre votre application.
*Une collection de services intégrés prêts à l'emploi pour décupler les possibilités de votre application.
*Inclut des fonctions essentielles comme les services d'annuaire d'utilisateurs et la gestion des utilisateurs, le suivi de l'emplacement de l'utilisateur et le stockage intégré des données.
*Configurez des groupes d'utilisateurs et ajoutez des utilisateurs via le portail RAD Server ou importez-les depuis LDAP. Assignez des droits d'accès API pour contrôler les fonctionnalités auxquelles ont accès les différents groupes d'utilisateurs.
*'''Nouveau''' : Prise en charge multi-client de RAD Server dans la version 10.2 : une seule instance RAD Server avec une seule connexion de base de données RAD Server peut prendre en charge plusieurs clients (tenants) isolés. Pour plus d'informations, voir la rubrique [[Support multi-client RAD Server|Prise en charge multi-client de RAD Server]].

==Comparaison avec DataSnap==

Avant RAD Server, les développeurs devaient construire des serveurs d'applications back-end Delphi et C++Builder en utilisant des toolkits pour serveur comme DataSnap qui fournissaient quelques blocs de construction basiques pour les infrastructures multi-niveaux, mais laissaient une bonne partie du développement à la charge des programmeurs. Avec RAD Server, les développeurs peuvent simplement charger des méthodes métier logiques Delphi et C++ dans RAD Server puis simplement ajouter des utilisateurs.

==Technologies intégrées==

{{Product}} {{Version}} inclut des fonctionnalités développeur pour RAD Server destinées au développement des '''points de terminaison REST et du suivi des emplacements''', des '''IoT Edgeware''' via les technologies Enterprise Mobility Services, BeaconFence, ThingPoint, et ThingConnect.

===Création, publication et gestion simplifiées des points de terminaison API REST===

RAD Server facilite et accélère la construction de serveurs back-end flexibles pour votre solution d'application multi-niveau. Il suffit aux développeurs de charger la logique métier Delphi et C++ dans le serveur pour générer des points de terminaison API REST/JSON gérés.

Pour développer des '''points de terminaison REST''' pour RAD Server, les développeurs utilisent les composants EMS [[RAD Server (EMS)|RAD Server (EMS)]] disponibles dans la palette d'outils sous la catégorie "Enterprise Mobility Services".

===Points d'accès IoT d'entreprise===

IoT Edgeware étend la fonctionnalité de publication de points de terminaison REST et fournit un point d'accès d'entreprise entre les gadgets et les périphériques distants. IoT Edgeware vous permet de stocker, filtrer et traiter localement de grandes quantités de données IoT collectées dans la périphérie tout en garantissant que seules les données critiques sont synchronisées avec le référentiel central.

Pour développer des composants '''IoT Edgeware''' pour RAD Server, les développeurs utilisent [[Présentation des ThingPoint|ThingPoint]], une extension d'EMS qui est représentée avec TEMSEdgeService dans la catégorie "Enterprise Mobility Services" de la palette d'outils dans l'EDI.

===Solution Proximité/Emplacement en intérieur et en extérieur===

Faites le suivi des mouvements utilisateur aussi bien à [https://www.youtube.com/watch?v=1_cWnDmvxJk l'intérieur qu'à l'extérieur], et répondez aux événements de proximité lorsque l'utilisateur entre dans une zone beacon personnalisée ou en sort, ou lorsqu'il approche des points beacon désignés.

Pour développer des composants '''Suivi des emplacements''', les développeurs utilisent les composants [[BeaconFence|BeaconFence]] disponibles en téléchargement via le [[Gestionnaire de packages GetIt|Gestionnaire de packages GetIt]].

===Framework de connectivité des périphériques intelligents IoT===

RAD Server facilite la connexion à une large gamme de périphériques sans fil et de capteurs ou détecteurs dans votre solution d'application, même dans des emplacements difficiles d'accès. Les développeurs ont accès à plus de 50 composants pré-construits pour de nombreux périphériques IoT Bluetooth LE et Z-Wave appliqués à la santé, au sport et à la domotique.

Pour connecter les périphériques IoT à des clients ou à RAD Server [[Présentation des ThingPoint|ThingPoint Edgeware]], les développeurs peuvent utiliser les composants IoT [[Iot:ThingConnect Devices|ThingConnect]], disponibles en téléchargement via le Gestionnaire de packages GetIt (via <code>Outils > Gestionnaire de packages GetIt > Internet of Things</code>).

==Evaluation==

Les versions Enterprise et Architect de Rad Studio (y compris l'édition d'évaluation) incluent une version développeur de RAD Server avec une licence de développement. Le déploiement d'une solution RAD Server pour des clients requiert une licence de déploiement distincte, qui peut être incluse avec l'édition de votre produit ou achetée séparément.

La version Professionnel de RAD Studio et les versions CE de Delphi et C++Builder n'incluent pas la prise en charge de RAD Server.

==Environnement de production==

[[RAD Server Database Requirements for a Production Environment on Windows|
'''Cliquez ici''']] pour visualiser les étapes relatives au déploiement de RAD Server dans un environnement de production.

Vous devez entrer la licence RAD Server.

Pour les ressources personnalisées, vous pouvez utiliser un outil tel que [http://www.dependencywalker.com http://www.dependencywalker.com] pour déterminer les dépendances bpl de chaque ressource personnalisée.

==Ressources pour démarrer==

Nous vous invitons à regarder la rediffusion du webinar RAD Server Deep Dive, divisé en plusieurs chapitres : [https://www.youtube.com/playlist?list=PLwUPJvR9mZHgccq4EfTcsCngRqpTmm_wn https://www.youtube.com/playlist?list=PLwUPJvR9mZHgccq4EfTcsCngRqpTmm_wn]

Les diapositives et les projets de démonstration utilisés dans le webinar peuvent être téléchargés [http://cc.embarcadero.com/item/30579 ici].

Des tutoriels présentant les différentes technologies intégrées dans '''RAD Server''' sont disponibles en cliquant sur les liens docwiki ci-dessus.

Pour plus de vidéos de présentation, consultez notre [https://www.youtube.com/results?search_query=rad+server+embarcadero chaîne YouTube].

===Projets exemples===

'''Publication de points de terminaison REST et IoT Edgeware'''

*Les exemples de code Delphi et C++ se trouvent dans {{CodeSamplesRepositories}}. Selon la version RAD Studio dont vous disposez, vous pouvez effectuer une recherche par nom dans les répertoires exemple.

'''Composants pour les périphériques ThingConnect IoT'''

*Pour chaque pack de composants IoT installé via le Gestionnaire de packages GetIt, vous pouvez trouver les projets exemples en accédant à : <code>C:\Users\Public\Documents\Embarcadero\Studio\19.0\Samples\Internet of Things\Object Pascal\Thing Connect</code>

'''Suivi de l'emplacement'''

*Une fois le pack de composants BeaconFence installé via le Gestionnaire de packages GetIt, vous pouvez trouver les projets exemples en accédant à : <code>C:\Users\Public\Documents\Embarcadero\Studio\19.0\Samples\Internet of Things\Object Pascal\Beacon Fence</code>

==EULA==

Le contrat de licence (EULA) de RAD Server est consultable en cliquant [http://embarcadero.com/products/rad-server/rad-server-eula ici].

==Page produit de RAD Server==

Pour une liste détaillée des fonctionnalités, consultez la [https://www.embarcadero.com/products/rad-server''' page produit de RAD Server''']

==Voir aussi==

*[[Support multi-client RAD Server|Support multi-client de RAD Server]]
*[[Modification manuelle de la configuration du moteur RAD Server|Modification manuelle de la configuration du moteur RAD Server]]
*[[Interface utilisateur de la console RAD Server|Interface utilisateur de la console RAD Server]]
*[[Application RAD Server Management Console|Application RAD Server Management Console]]

Propriétés de projet

Yukikoi — Fri, 09 Oct 2026 18:13:01 GMT

Yukikoi a importé Propriétés de projet par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Options C++}}
{{Parent|Boîte de dialogue Options de projet}}

{{Menu|Outils > Options > Langage > Options C++ > Propriétés de projet}}

{{Menu|Projet > Options > Propriétés de projet}}

Définit les propriétés qui contrôlent certains aspects de la façon dont l'EDI gère un nouveau projet C++Builder :

*La page '''Options de projet''' contrôle les paramètres C++ pour le projet en cours uniquement.
*La page '''Options des outils''' contrôle les paramètres C++ par défaut pour les nouveaux projets uniquement.

{| border="1" frame="hsides" rules="rows"
|-
!'''Options des propriétés de projet C++'''
!'''Description'''
|-
|Utiliser la vérification d'auto-dépendance, si disponible
|Lorsqu'un fichier objet existe déjà pour un fichier source, un outil crée un nouveau fichier objet si la date de modification du source est plus récente que celle du fichier objet. Quand cette option est cochée, l'outil construit un nouveau fichier objet si l'un des fichiers d'inclusion dont dépend un fichier source a une date de modification plus récente que celle du fichier objet. Si elle n'est pas cochée, l'outil ne vérifie pas tous les fichiers d'inclusion. L'activation de cette option garantit des constructions plus précises. Valeur par défaut = <code>true</code>.
|-
|Vérifier les bibliothèques et les importations de packages
|Si cette option est cochée, vérifie que toutes les bibliothèques associées aux packages peuvent être trouvées avant la liaison. Si un fichier n'est pas trouvé, affiche un dialogue demandant à l'utilisateur l'emplacement et met à jour les chemins d'inclusion en conséquence. Lorsque cette option n'est pas cochée, cette vérification n'a pas lieu. Valeur par défaut = <code>true</code>
|- valign="top"
|
Gérer les chemins de bibliothèques et d'inclusion
|
Quand un utilisateur ajoute des fichiers au projet (et que cette option est cochée), ajoute les chemins de ces fichiers aux options de chemin d'inclusion appropriées pour garantir que le compilateur/lieur trouvera les fichiers. Si elle n'est pas cochée, ne met pas à jour automatiquement les chemins d'inclusion. C'est alors l'utilisateur qui garantit que les chemins de bibliothèques et d'inclusion sont corrects. Valeur par défaut = <code>true</code>
|- valign="top"
|
Afficher les dépendances d'en-tête dans le gestionnaire de projets
|
Si cette option est cochée, crée et affiche la liste de tous les fichiers d'en-tête dont dépend un fichier C/C++ dans le gestionnaire de projets, si les informations sont disponibles. Si elle n'est pas cochée, ne génère pas la liste. Valeur par défaut = <code>false</code>
|- valign="top"
|
Fichiers d'index pour 'Définitions et références' <br />
(Prise en charge pour les plates-formes cible Windows 64 bits, iOS et Android)
|
Sur la page '''Options de projet''', active la prise en charge de l'indexeur ('''[[Rechercher les définitions et les références (C++)|Rechercher les références (C++)]]''') pour le projet C++ en cours. Une fois activée, vous accédez aux commandes '''Chercher''' depuis le [[Menu contextuel de l'éditeur de code|menu contextuel de l'éditeur de code]]. Valeur par défaut = <code>false</code>.
Sur la page '''Options des outils''', active '''[[Rechercher les définitions et les références (C++)|Chercher les références (C++)]]''' pour tous vos projets C++.
Lorsque vous activez cette option, une base de données SQLite est créée dans le dossier de projet en cours.
|- valign="top"
|
Afficher les messages généraux
|
Affiche [[Messages d'information (C++)|tous les messages]] des outils sans filtrage. Valeur par défaut = <code>false</code>
|- valign="top"
|
Mappage de _TCHAR en <br />
(seulement dans la page Outils > Options)
|
Spécifie que le <code>typedef _TCHAR</code> migre vers une définition étroite <code>char</code> (<code>AnsiString</code>) ou vers une définition étendue <code>wchar_t</code> (<code>UnicodeString</code>). Quand vous définissez cette option sur <code>wchar_t</code>, il définit alors les <code>UNICODE</code> et <code>_UNICODE</code> en projets et migre vers les définitions étendues de la bibliothèque standard et des fonctions de l'API. Valeur par défaut = <code>wchar_t</code>. Voir [[Mappage TCHAR|Mappage _TCHAR]].
|- valign="top"
|
<span id="separate-process">Exécuter le compilateur C++ dans un processus distinct</span><br />
(disponible uniquement dans la page Options de projet)
|
Démarre un processus de compilation distinct, en dehors de l'EDI, quand vous exécutez une commande Make ou Construire. Cette option est utile pour la compilation de gros projets qui produisent des erreurs de dépassement de la mémoire du compilateur quand l'exécution de ce dernier s'effectue in-process (en utilisant la commande Make ou Construire). Un dialogue '''d'enregistrement de fichiers''' vous invite à enregistrer votre projet avant la compilation, sauf si vous l'avez déjà enregistré.
Si vous utilisez [[Compilateurs C++ améliorés par Clang|compilateur C++ amélioré par Clang]], vous pouvez utiliser l'option "Exécuter le compilateur C++ dans un processus distinct" en combinaison avec l'option [[Compilateur C++#batch-compilation|"Activer la compilation groupée"]] pour activer la [[Compilateurs C++ améliorés par Clang#Utilisation de la compilation parallèle|compilation parallèle.]].
"Nombre de sous-processus" détermine le nombre de sous-processus que le compilateur peut générer pour effectuer la compilation parallèle. Ce nombre ne peut pas être supérieur au nombre de coeurs de votre processeur.
Par défaut, cette option est désactivée.
|-
|Nombre de sous-processus
|Aussi connu sous la forme de {{Code|--jobs}}. Cette commande exécute plusieurs processus du compilateur C++ à la fois, selon votre configuration. Cette option est toujours activée lorsque vous choisissez une compilation en groupe (compilation batch).
Pour plus d'informations, consultez la page [[BCC64X|BCC64X]].
|}

==Voir aussi==

*[[Mappage TCHAR|Mappage _TCHAR]]
*[[Menu contextuel de l'éditeur de code|Menu contextuel de l'éditeur de code]]
*[[Rechercher les définitions et les références (C++)|Chercher les références (C++)]]
**[[Aller aux éléments associés (C++)|Aller aux éléments associés (C++)]]
**[[Show Type Hierarchy (C++)|Afficher la hiérarchie des types (C++)]]
**[[Go to Type Declaration (C++)|Aller à la déclaration de type (C++)]]
**[[Show Base Types (C++)|Afficher les types de base (C++)]]
**[[Show Derived Types (C++)|Afficher les types dérivés (C++)]]

[[Category:Référence RAD Studio]]
[[Category:C++]]
[[Category:AMMigrate]]

Pragma alias

Yukikoi — Fri, 09 Oct 2026 18:13:01 GMT

Yukikoi a importé Pragma alias par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{DISPLAYTITLE:#pragma alias}}
{{Parent|Présentation des directives pragma - Index}}

==Syntaxe <span style="font-size: 60%">(voir [[Pseudo-grammaire|Pseudo-grammaire]])</span>==

'''Chaîne d'outils classique''' :

#pragma alias "aliasName" = "substituteName"

'''Chaîne d'outils Clang''' :<br />
la directive <code>#pragma alias</code> n'est pas supportée par les compilateurs [[BCC64X|BCC64X]] et [[Compilateurs Win32 améliorés par Clang|BCC32C]]. A la place, vous pouvez laisser un commentaire pour le lieur en procédant comme suit :<br />

#pragma comment(linker, "/alternatename:<name1><nowiki>=</nowiki><name2>")

==Description==

<code>#pragma alias</code> indique au lieur que deux noms d'identificateurs sont équivalents. Les deux identificateurs doivent être saisis entre guillemets. Sinon, un avertissement [[W8086 Utilisation incorrecte de l'alias pragma "NomAlias"="NomSubstitué" (C++)|W8086 Utilisation incorrecte de l'alias pragma "aliasName"="substituteName" (C++)]] est émis.

Les alias sont à présent gérés dans des unités distinctes, par deux fichiers .obj, un pour Unicode et un pour non-Unicode. Ces deux fichiers .obj font partie de la bibliothèque VCL.

Le <code>NomAlias</code> et le <code>NomSubstitué</code> sont injectés dans leur fichier .obj correspondant, exactement comme ils sont écrits à l'intérieur des guillemets. Le lieur recherche toutes les références à <code>NomAlias</code> et les lie au <code>NomSubstitué</code>.

{{Note| Les [[Fichier d'en-tête C++ (*.h, *.hpp)|fichiers .hpp]] générés depuis le code {{Delphi}} utilisent l'alias <code>#pragma</code> pour la gestion des identificateurs qui sont substantypés différemment dans {{Delphi}} et {{CBuilder}}.}}

[[Category:Référence C++]]
[[Category:C++]]

Packages pour la nouvelle chaîne d'outils C++

Yukikoi — Fri, 09 Oct 2026 18:13:01 GMT

Yukikoi a importé Packages pour la nouvelle chaîne d'outils C++ par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Référence C++}}
Les packages sont un concept {{Delphi}} fondamental et ne sont pas parfaitement transposés en C++, ce qui entraîne des problèmes et complexifie les choses lors de l'utilisation des packages.

Par exemple, les unités sous forme de fichier .pas sont un concept de {{Delphi}}. Le C++ possède des unités de traduction, mais ce n'est pas vraiment la même chose. Le code peut exister dans un en-tête sans appartenir à un fichier .cpp spécifique.

Pour gérer cela, vous devez utiliser [[Pragma package|#pragma package(smart_init)]] dans une unité. Cela revient à marquer une unité de compilation comme une unité de style {{Delphi}} (dans la mesure où ces concepts peuvent être rapprochés) dans le sens utilisé par ce document et les articles associés.

Veuillez consulter les sections suivantes pour mieux comprendre le sujet.

==Initialisation et finalisation des unités==

Dans la nouvelle chaîne d'outils, {{Product}} améliore considérablement la gestion des packages dans un but d'assurer un comportement cohérent lors de la liaison statique et dynamique de packages.

Pour plus d'informations, consultez la page [[Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++|Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++]].

==Importation et exportation de packages==

Pour comprendre l'effet du modificateur PACKAGE ou [[Declspec(package)|__declspec(package)]], consultez la page [[Importation et exportation de package pour la nouvelle chaîne d'outils C++|Importation et exportation de packages]].

==Unités faiblement packagées de Delphi==

De plus, il est important de savoir pourquoi les [[Utilisation de la directive de packaging faible|unités faiblement packagées sont différentes des unités normales]].

==Avertissement de compatibilité==

Les BPL (packages C++) créés avec l'ancienne chaîne d'outils sont incompatibles avec les applications construites avec la nouvelle chaîne d'outils et inversement. Autrement dit, pour les applications {{code|Windows 64 bits (Moderne)}}, assurez-vous d'utiliser des packages C++ compilés avec {{code|Windows 64 bits (Moderne)}}. Ne mélangez pas les chaînes d'outils pour les différents fichiers qui composent votre application.

Cette limitation s'applique uniquement aux packages C++, car les packages construits par Delphi sont compatibles avec les deux chaînes d'outils. Ainsi, les packages Delphi peuvent être utilisés aussi bien par [[BCC64|Win64 (Ancien)]] que par [[BCC64X|Win64 Moderne]]. L'inverse fonctionne également : les apps Delphi peuvent [[Chargement des packages avec la fonction LoadPackage|charger des packages]] construits avec Win64 (Ancien) ou Win64 (Moderne). Toutefois, Win64 (Ancien) ne peut pas charger des packages construits par Win64 Moderne, et Win64 Moderne ne peut pas charger des packages construits par Win64 Ancien. Si vous les mélangez, vous obtiendrez des messages de violation d'accès ou d'autres erreurs.

===Voir aussi===

* [[Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++|Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++]]
* [[Importation et exportation de package pour la nouvelle chaîne d'outils C++|Importation et exportation de packages pour la nouvelle chaîne d'outils C++]]
* [[Build Delphi Packages for C++|Construction de packages Delphi pour C++]]
* [[Utilisation de la directive de packaging faible|Utilisation de la directive de package faible]]
*[[BCC64X|BCC64X]]

Importation et exportation de package pour la nouvelle chaîne d'outils C++

Yukikoi — Fri, 09 Oct 2026 17:05:26 GMT

Yukikoi a importé Importation et exportation de package pour la nouvelle chaîne d'outils C++ par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Packages pour la nouvelle chaîne d'outils C++}}

Lorsque le modificateur PACKAGE ou [[Declspec(package)|__declspec(package)]] est utilisé, il est difficile de comprendre quand les éléments sont importés ou exportés. {{Product}} applique des heuristiques et considère qu'une classe est traitée en tant que [[Declspec(dllexport)|__declspec(dllexport)]] lorsque les conditions suivantes sont réunies :

* La classe est marquée comme <code>[[Declspec(package)|__declspec(package)]]</code> et contient une déclaration de fonction non-inline.
* Le fichier qui contient la classe est compilé avec l'option <code>-tP</code>.

Sinon, la classe est considérée comme [[Declspec(dllimport)|__declspec(dllimport)]].

En résumé, il s'agit de '''suppositions'''. Il n'existe aucun moyen fiable de mapper une déclaration dans un fichier d'en-tête {{CBuilder}} pour savoir s'il doit être exporté ou importé, ce qui justifie l'application d'heuristiques. En règle générale, en présence d'une [[Declspec(package)|macro PACKAGE]] le compilateur suppose que le package essaie d'effectuer une exportation lors de la construction d'un projet de package. Il suppose sinon que c'est une importation.

Notez que nous utilisons des méthodes inline dans nos fichiers HPP. Elles concernent généralement les constructeurs, en raison des différences de disponibilité dans les classes descendantes ({{Delphi}} hérite de tous les constructeurs). Toutefois, ces méthodes n'empêchent pas une classe d'être importée selon les heuristiques. En bref, on retiendra que des heuristiques sont appliquées si [[Declspec(package)|__declspec(package)]] est utilisé.

La raison de ce comportement vient du fait que les packages tentent de transposer un concept {{Delphi}} en {{CBuilder}}, sans y parvenir parfaitement. En règle générale {{Product}} recommande d'utiliser les packages avec prudence. En privilégiant des usages qui correspondent à {{Delphi}} (comme c'est le cas avec les composants), vous aurez plus de chances de réussite que si vous utilisez un package de la même façon qu'une DLL, alors qu'il serait préférable d'utiliser une DLL ou une bibliothèque statique.

===Exemple de code===

{{#tag:syntaxhighlight|
class PACKAGE TMyComponent : public TComponent {
public:

__fastcall TMyComponent(TComponent* Owner);
void __fastcall DoSomething();

};

|lang=c++}}Dans cet exemple, la classe TMyComponent utilise la macro PACKAGE (qui est développée en decspec(package).) En conséquence, le compilateur applique des heuristiques pour déterminer si vous souhaitez exporter ou importer la classe.

==Recommandations==

Veuillez prendre en compte les recommandations suivantes lorsque vous utilisez l'importation et l'exportation de packages avec la nouvelle chaîne d'outils C++. Cela vous permettra d'éviter des problèmes.

* Evitez d'utiliser les méthodes générées par défaut ou générées par le compilateur dans une classe marquée comme package. Suivez la [https://en.cppreference.com/w/cpp/language/rule_of_three règle des trois/cinq].
* En toutes circonstances, vous ne devez pas utiliser les méthodes inline dans les types de vos packages importés ou exportés, même s'ils sont simples. Vous devez explicitement placer toutes les méthodes (y compris le constructeur/destructeur/constructeur de copie, et les [https://en.cppreference.com/w/cpp/language/rule_of_three autres]) dans le fichier .cpp.
* Nous vous recommandons fortement de ne pas exporter les types de templates, car ils sont par définition "inlinés" et peuvent provoquer des définitions multiples.
* Soyez prudent avec les dépendances entre unités, et apprenez à maîtriser [[Unit Initialization and Finalization for C++ New Toolchain|l'initialisation et la finalisation des unités]].
* De manière générale, nous recommandons fortement de ne pas utiliser PACKAGE ou [[Declspec(package)|__declspec(package)]] sauf dans des usages très simples. A la place, nous vous conseillons de marquer manuellement vos types avec [[Declspec(dllimport)|__declspec(dllimport)]] et [[Declspec(dllexport)|__declspec(dllexport)]].<br /> {{Tip|Une autre approche consiste à wrapper les modificateurs dans une macro dont la valeur dépend de l'emplacement de l'en-tête. En d'autres termes, votre projet EXE peut définir une macro afin qu'une importation soit effectuée lorsque l'en-tête est inclus.}}
* Les packages étant des DLL étendues, ces directives dllimport/dllexport s'appliquent. Le point clé ici est qu'en les marquant explicitement, le compilateur n'a plus besoin de deviner, car il reçoit une directive claire du programmeur lui indiquant d'effectuer une importation ou une exportation. Les packages sont très pratiques pour les composants et utiles pour les types basés sur {{Delphi}}, mais il est préférable d'utiliser des DLL pour l'exécution dynamique. <br />{{Attention|Notez qu'il n'y a pas d'enracinement de type entre modules dans C++.}}

===Voir aussi===

* [[Packages for C++ New Toolchain|Packages pour la nouvelle chaîne d'outils C++]]
* [[Unit Initialization and Finalization for C++ New Toolchain|Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++]]
*[[Declspec(dllimport)|__declspec(dllimport)]]
*[[Declspec(dllexport)|__declspec(dllexport)]]
*[[BCC64X|BCC64X]]

Audit de code intelligent

Yukikoi — Fri, 09 Oct 2026 17:05:26 GMT

Yukikoi a importé Audit de code intelligent par téléversement de fichier (1 version) LOC-23451

Nouvelle page

[[Audit de code intelligent|Smart CodeInsight]] est une architecture ouverte qui vous permet d'utiliser vos moteurs d'IA préférés. En plus des fonctionnalités déjà présentes, {{Product}} vous propose également une intégration de l'interface utilisateur personnalisable :

* Moteur d'IA de base et ToolsAPI.
*Intégration de l'EDI :
** [[#Options de configuration|Options de configuration pour les moteurs]].
** [[#Commandes de menu de l'éditeur|Commandes de menu de l'éditeur permettant d'invoquer des opérations IA]].
** [[#Fenêtre de chat IA|Fenêtre de chat IA]].
* Prise en charge des fournisseurs LLM en ligne et hors ligne tels que :
** OpenAI, Gemini et Claude (en ligne).
** Ollama (hors ligne).

:
::{{Tip| Ollama est distribué en tant que produit open source sous licence MIT. Les modèles individuels que vous êtes susceptible d'utiliser avec Ollama ont leurs propres licences. La politique d'utilisation "Codellama Acceptable Use Policy" est disponible sur cette page.}}
::{{Note| Pour les adeptes de ToolsAPI, {{Product}} vous permet de créer votre propre plugin API. Pour plus d'informations, consultez la page [[Create and implement your AI plugin|Créer et implémenter votre plugin IA]].}}

{{Warning|{{Product}} ne fournit pas d'accès à ces moteurs. L'utilisation de ces services d'IA nécessite que l'utilisateur accepte les conditions d'utilisation de chaque éditeur, reçoive une clé API permettant d'entrer dans la configuration de {{Product}}, et paie les frais de licence de la société d'IA concernée.
La seule exception concerne Ollama qui peut être utilisé hors ligne gratuitement et être installé en local ou sur un serveur de votre choix.}}

==Options de configuration==

{{Product}} vous permet de configurer et de contrôler pleinement la confidentialité de différentes façons. Vous pouvez ainsi :

* Désactiver la fonctionnalité IA complète à partir d'un paramètre unique.
* Activer ou désactiver chacun des quatre moteurs.
* Sélectionner le moteur par défaut de chacun des éléments d'interface utilisateur (fenêtre de chat et menu éditeur).

Toutes ces fonctionnalités peuvent être configurées dans la fenêtre Options de l'EDI. Consultez la page [[Options relatives à l'audit de code intelligent|Configuration de l'audit de code intelligent]] pour plus d'informations sur chaque rubrique.

* Les actions suivantes ont aussi été implémentées pour sécuriser le système.
* Les clés API sont stockées dans un format chiffré.
* Vous avez la possibilité d'utiliser un moteur local, hors ligne.

==Commandes du menu Editeur==

Le menu Editeur propose des opérations préconfigurées pour le code sélectionné dans l'éditeur. Le but est d'analyser et d'optimiser une partie du code source de votre application.

Le moteur LLM réagit en renvoyant le résultat dans une fenêtre de l'éditeur sous forme de commentaire après le code analysé.

===Commandes disponibles :===

Voici les commandes disponibles pour l'audit de code intelligent :

[[Image:Smart CodeInsight-Display.png|450x450px|link=]]

* '''Chat IA''' : ouvre la vue [[#Fenêtre de chat IA]].
* '''Trouver des bogues''' : recherche des bogues potentiels dans le code sélectionné.
* '''Expliquer le code''' : explique le code sélectionné.
* '''Ajouter un commentaire''' : ajoute des commentaires au code sélectionné.
* '''Achever le code''' : termine le code sélectionné.
* '''Optimiser le code''' : optimise le code sélectionné.
* '''Ajouter un test unitaire''' : ajoute un test unitaire au code sélectionné.
* '''Convertir en assembleur''' : convertit le code sélectionné en code assembleur.
* '''Convertir en Delphi''' : convertit le code sélectionné en code Delphi (à partir du code C++ ou assembleur).
* '''Convertir en C++Builder''' : convertit le code sélectionné en code C++Builder.
* '''Trouver l'en-tête (IA)''' (dans C++) ou '''Rechercher une unité''' (dans Delphi) : ajoute l'unité manquante aux instructions uses d'une classe sélectionnée ou d'un type de données.
* '''Afficher le résultat dans l'éditeur''' : envoie la sortie dans l'éditeur.
* '''Afficher le résultat dans le Chat''' '''''' : envoie la sortie dans la fenêtre de chat IA au format Markdown.

==Compagnon RAD AI==

RAD Studio introduit "RAD AI Companion" web, un chat et générateur de code spécifiquement entraîné sur du contenu en lien avec RAD Studio. Le compagnon RAD AI s'active depuis l'EDI en sélectionnant {{Menu| Menu Aide > [http://www.embarcadero.com/radaicompanion RAD AI Companion]}}.

==Fenêtre de chat IA==

La fenêtre de chat IA est une fiche ancrable de l'EDI, qui fonctionne comme n'importe quelle fenêtre de chat LLM. Vous pouvez taper une requête, choisir un moteur (ou utiliser le moteur par défaut) et attendre la réponse. Voici un rapide exemple :

[[Image:ai chat window.png|350px|link=]]

La fenêtre de chat comporte une zone de saisie qui fonctionne comme une ligne de commande. Voici les commandes disponibles :

* <code>chatgpt> + Entrée</code> : active ChatGpt comme moteur d'IA actif (si celui-ci a été activé).
* <code>gemini> + Entrée</code> : active Gemini comme moteur d'IA actif (si celui-ci a été activé).
* <code>claude> + Entrée</code> : active Claude comme moteur d'IA actif (si celui-ci a été activé).
* <code>ollama> + Entrée</code> : active Ollama comme moteur d'IA actif (si celui-ci a été activé).
* <code>clear> + Entrée</code> : efface la zone de réponse.
* <code>stop> + Entrée</code> : arrête la génération de la réponse (équivalent à un clic sur le bouton Stop).
* <code>Ctrl + Entrée</code> : commence à générer la réponse (équivalent à un clic sur le bouton Start).

En plus des requêtes standard, vous pouvez sélectionner un snippet de code spécifique dans la fenêtre de code et poser une '''nouvelle question''' ou '''demander une explication''' en utilisant l'une des commandes suivantes :

[[Image:ai smartchat.png|450px|link=]]

*$COL : correspond au '''numéro de colonne''' sur lequel le curseur est placé dans la fenêtre éditeur de code active.
*$ROW : correspond au '''numéro de ligne''' sur lequel le curseur est placé dans la fenêtre éditeur de code active.
*$CURTOKEN : correspond au '''mot''' sur lequel le curseur est placé dans la fenêtre éditeur de code active. Cette commande peut être utile pour faire référence à une variable, une méthode ou un identificateur situé à l'emplacement du curseur.
*$EDNAME : correspond au '''nom de fichier complet''' de la fenêtre éditeur de code active. Cette commande peut être très utile si vous avez besoin du nom du fichier en cours avec son chemin d'accès.
*$SELECTION : fournit des explications sur le code sélectionné dans l'éditeur actif.
*$UNIT : fournit des explications sur le code de l'unité.

Consultez la page [[Macros de transfert|Macros de transfert]] pour plus d'informations et d'exemples.

===Voir aussi===

* [[Options relatives à l'audit de code intelligent|Options relatives à l'audit de code intelligent]]
* [[Configuring Ollama for Smart CodeInsight|Configuration d'Ollama]]
* [[Create and implement your AI plugin|Créer et implémenter votre plugin IA]]

Options relatives à l'audit de code intelligent

Yukikoi — Fri, 09 Oct 2026 17:05:26 GMT

Yukikoi a importé Options relatives à l'audit de code intelligent par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Options de l'EDI}}
{{Menu| Outils > Options > EDI > [[Audit de code intelligent|Audit de code intelligent]]}}

Vous pouvez configurer l'intégration de '''l'audit de code intelligent''' dans la partie Audit de code intelligent de la fenêtre Options des outils, comme indiqué dans l'image ci-dessous.

[[File:Smart codeinsight options available.png|600px|link=]]

Sur cette fenêtre, vous pouvez configurer l'intégration IA à partir des champs suivants :

*La case à cocher '''Activer le moteur IA''' permet d'activer la fonctionnalité.
*Les zones de liste déroulante '''IA par défaut pour l'éditeur''' et '''IA par défaut pour la fenêtre de Chat''' vous permettent de choisir l'IA disponible pour chacun des éléments.

De plus, dans la section '''Plugins''', vous pouvez configurer chacun des moteurs IA dans son onglet en spécifiant ses propres paramètres de configuration. Vous trouverez ci-dessous les options initiales suggérées pour chacun des moteurs :

{| class="wikitable" style="width:100%"
|-
! style="width:12%" |Configuration
! style="width:22%" |ChatGPT
!Ollama**
! style="width:22%" |Gemini
! style="width:22%" |Claude
|-
|'''BaseURL'''
|<nowiki>https://api.openai.com/v1</nowiki>
|Dépend de l'installation.
Si c'est un "localhost" avec l'option par défaut, l'URL de base est <nowiki>http://localhost:11434/</nowiki>
|<nowiki>https://generativelanguage.</nowiki><wbr><nowiki>googleapis.com/v1beta</nowiki>
|<nowiki>https://api.anthropic.com/v1</nowiki>
|-
|'''APIKey'''
|[https://platform.openai.com/account/api-keys Clé API dans OpenAI]
| style="background-color:#e6e6e6;" |
| [https://console.cloud.google.com/apis/dashboard Clé API dans l'API et les Services Google Cloud]
|[https://console.anthropic.com/settings/keys Clé API dans Anthropic]
|-
|'''Model*'''
|gpt-4
|codellama
|models/gemini-pro
|claude-3-5-sonnet-20240620
|-
|'''Timeout''' (milliseconds)
|30.000
|30.000
|30.000
|30.000
|-
|'''Maxtoken'''
|2048
| style="background-color:#e6e6e6;" |
|2048
|1024
|-
|'''Temperature'''
|0.1
| style="background-color:#e6e6e6;" |
|0.9
| style="background-color:#e6e6e6;" |
|-
| '''TopP'''
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
|1
| style="background-color:#e6e6e6;" |
|-
| '''TopK'''
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
|1
| style="background-color:#e6e6e6;" |
|-
| '''Anthropic Version'''
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
| style="background-color:#e6e6e6;" |
|2023-06-01
|}

Une fois la configuration terminée, vous pouvez utiliser le bouton '''Tester la connexion''' pour tester la configuration sans avoir besoin de lancer le chat.

{{Note| '''(*)''' RAD Studio suggère une liste de modèles disponibles, obtenus depuis le moteur d'IA précédemment configuré. Cette fonctionnalité est disponible pour tous les moteurs d'IA, à l'exception de Claude. }}

{{Attention| '''(**)''' Si vous configurez Ollama, vous pouvez utiliser une image Docker pour l'installer. Pour plus d'informations, consultez la page Configuration d'Ollama pour l'audit de code intelligent}}
{{Tip|Pour rendre le moteur opérationnel, vous devez effectuer les étapes suivantes :

<ol><li>Configurer un moteur (l'un de ceux mentionnés ci-dessus).</li>
<li>Activer la case à cocher '''Activé''' de ce moteur d'IA.</li>
<li>Choisir le moteur pour l'éditeur et pour la fenêtre de chat.}}

===Voir aussi===
* [[Page d'accueil|Page Bienvenue]]
* [[Mise à niveau des projets|Mise à niveau des projets]]
* [[Audit de code intelligent|Audit de code intelligent]]
</li>
</ol>

Présentation de l'EDI

Yukikoi — Fri, 09 Oct 2026 17:05:26 GMT

Yukikoi a importé Présentation de l'EDI par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Introduction à RAD Studio}}

Quand vous démarrez {{Variables|Product}}, l'environnement de développement intégré (EDI) s'ouvre et affiche plusieurs outils et menus. L'EDI vous aide à concevoir visuellement des interfaces utilisateur, à définir les propriétés des objets, à voir et gérer votre application de diverses façons.

Cette rubrique d'aide décrit les outils qui sont disponibles dans l'EDI. Sachez que les outils spécifiques qui sont disponibles varient selon l'édition de {{Variables|Product}} que vous utilisez.

==Page d'accueil==

Lorsque vous ouvrez {{Product}}, les sections de la '''[[Page d'accueil|page d'accueil]]''' affichent différents types d'informations utiles et proposent des actions.

La '''page d'accueil''' comporte plusieurs cadres que vous pouvez ajouter, supprimer, repositionner ou redimensionner comme vous le souhaitez pour organiser les sections avec les informations que vous considérez comme les plus utiles pour commencer.

Si vous fermez la '''page d'accueil''', vous pouvez la rouvrir en choisissant {{Menu|Voir > Page d'accueil}}.

[[File:Welcome page1.png|border|link=|950px]]

{{Note| Une balise '''[Administrateur]''' s'affiche au début du libellé de la barre de titre lorsque vous exécutez '''l'EDI''' avec des privilèges élevés.}}

==[[Style EDI|Thème foncé]]==

{{Product}} {{Version}} vous permet de choisir un thème foncé pour l'EDI. Le thème foncé s'applique à un schéma de couleurs complètement différent et fournit une apparence adaptée à une utilisation prolongée ou à un environnement à faible luminosité.

Les options du thème EDI vous permettent de réaliser les actions suivantes :

*Faire correspondre au thème Windows
*Activer le thème foncé
*Activer le thème clair
*Activer le thème Mountain Mist
*Choisir les couleurs prédéfinies pour l'éditeur et pour l'inspecteur d'objets indépendamment du thème de l'EDI sélectionné.
*Choisir la couleur de la barre de titre

Pour accéder aux options relatives aux thèmes de l'EDI, choisissez {{Menu|Outils > Options > Interface utilisateur > [[Style EDI|Style de l'EDI]]}} ou cliquez sur le menu déroulant accessible dans la barre supérieure, à côté de la zone de liste déroulante des dispositions.

[[File:Top Bar Menu.png|link=]]

==Options d'accessibilité==

Avec l'EDI, vous pouvez utiliser les outils MSAA (MS Active Accessibility). Vous pouvez activer les outils d'accessibilité de Windows à partir du menu Démarrer via <font color="#598527">'''Tous les programmes > Accessoires > Accessibilité'''</font>.

==Dispositions du bureau et option d'auto-enregistrement Bureau du projet==

La disposition du bureau par défaut de l'EDI comporte les outils les plus fréquemment utilisés ({{Menu|Outils > Options > EDI > [[Bureau et disposition|Bureau et Disposition]]}}). Vous pouvez utiliser le menu Voir pour afficher ou masquer certains outils. Vous pouvez aussi personnaliser votre bureau en déplaçant et en supprimant des éléments, et [[Enregistrement des dispositions du bureau|enregistrer les dispositions du bureau]] qui vous conviennent le mieux.

Les paramètres du bureau sont enregistrés dans un fichier <code>.dsk</code>, et l'option '''d'enregistrement automatique du bureau du projet''' (sur {{Menu|Outils > Options > EDI > [[Saving and Recovering|Enregistrement et récupération]]}}) permet d'enregistrer un fichier <code>.dsk</code> pour le projet en cours. Le fichier <code>.dsk</code> conserve aussi les points d'arrêt et les points de suivi en cours. Le fichier <code><monprojet>.dsk</code> est enregistré dans votre dossier projet. Voir [[Enregistrement des dispositions du bureau|Enregistrement des dispositions du bureau]].

==Onglets Editeur==

La partie centrale de la fenêtre principale de l'EDI affiche une série d'onglets avec plusieurs fichiers code source et d'autres éléments ouverts. Il s'agit de l'espace de travail central. Les onglets contiennent généralement du code source ou un concepteur de fiches, mais ils peuvent aussi contenir un éditeur spécial ou des panneaux d'information, qui ont tous des couleurs différentes pour que vous puissiez les différencier des onglets normaux de code/concepteur.

[[File:Welcome screen tabs.png|link=|550px]]

Les onglets peuvent être déplacés hors de leur fenêtre ou dupliqués en cliquant dessus avec le bouton droit et en sélectionnant '''Déplacer >''' ou '''Fractionner >''' à gauche, à droite, en haut ou en bas de l'EDI. Pour de plus amples informations, voir [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]].

Vous pouvez modifier le comportement de l'onglet (comme le bouton Fermer ou la fermeture automatique des onglets) ou l'affichage des couleurs sur la page de l'onglet [[IDE Options|Options de l'EDI]].

==Utilisation d'une fiche==

{{f|webdocs|En général, une fiche représente une fenêtre ou une page HTML dans l'interface utilisateur que vous concevez.|En général, une fiche représente une fenêtre dans l'interface utilisateur que vous concevez.}} Au moment de la conception, une fiche est affichée sur la surface du concepteur. Ajoutez des composants de la '''[[Palette d'outils|Palette d'outils]]''' sur la fiche pour créer votre interface utilisateur.

{{Variables|Product}} propose une bibliothèque enrichie de fiches, comme décrit dans la section suivante. Sélectionnez la fiche la plus adaptée à la conception de votre application, qu'il s'agisse d'une application Web proposant des fonctionnalités de logique métier via le Web ou une application Windows proposant le traitement et l'affichage performant de contenu. Pour naviguer entre le concepteur et '''[[Editeur de code|l'éditeur de code]]''', cliquez sur leur onglet respectif en bas de l'EDI.

Pour accéder aux fiches, choisissez <font color="#598527">'''Fichier > Nouveau > Autre'''</font>.
{{f|vcl|2=

===Fiches VCL===

Utilisez {{Variables|VCLForms}} pour créer des applications natives utilisant des composants VCL.

Pour créer une application {{Variables|VCLForms}}, choisissez <font color="#598527"> '''Fichier > Nouveau > Autre > [[Application Fiches VCL|Application Windows VCL]]'''</font>.

Utilisez ensuite les classes de composants VCL pour créer votre application. Pour parcourir la bibliothèque VCL, voir [[lib_fr:Main Page|Référence VCL]].
}}

==Concepteur de fiches==

Le '''[[Concepteur de fiches|Concepteur de fiches]]''', ou le concepteur, est affiché automatiquement dans le volet central quand vous utilisez une fiche. L'apparence et les fonctionnalités du concepteur dépendent du type de fiche que vous utilisez. {{f|webdocs|Par exemple, si vous utilisez une fiche Web, le concepteur affiche un éditeur de balise HTML.}} Pour accéder au concepteur, cliquez sur l'onglet '''Conception''' en bas de l'EDI.

===Composants visuels===

Les composants visuels apparaissent dans la fiche lors de la conception et sont visibles pour l'utilisateur final à l'exécution. Ce sont les boutons, les libellés, les barres d'outils et les zones de liste.
{{f|vcl|2=

===Aperçu d'une fiche [[File:FormPreview.png]]===

Une icône d'aperçu en bas à droite du concepteur (pour les fiches VCL) présente le positionnement de votre fiche sur l'écran à l'exécution. Vous pouvez ainsi positionner les fiches de votre application les unes en fonction des autres, au fur et à mesure que vous les concevez. Lorsque vous déplacez la fiche dans la fenêtre d'aperçu, les coordonnées x,y du coin supérieur gauche de la fiche sont affichées. Par exemple, "0,0" représente le coin supérieur gauche de l'écran.

===Concepteur HTML===

Utilisez le '''concepteur HTML''' pour visualiser et modifier les fiches Web ou les pages HTML. Ce concepteur comporte un '''Editeur de balise''' pour modifier les balises HTML avec la représentation visuelle de la fiche ou de la page. Vous pouvez aussi utiliser '''l'inspecteur d'objets''' pour modifier les propriétés des éléments visibles de la page HTML et afficher les propriétés de la balise HTML en cours dans '''l'éditeur de balise'''. Une boîte à options située au-dessus de '''l'éditeur de balise''' vous permet d'afficher et de modifier les balises SCRIPT.

Pour créer un nouveau fichier HTML, choisissez {{Menu|Fichier > Nouveau > Autre > Web > Page HTML}}.
}}

===Directives de conception===

Si vous créez un composant pour une fiche, vous pouvez enregistrer un type d'objet, puis indiquer différents points sur ses limites, ou proches d'elles, qui constitueront des points "d'alignement". Ces points d'alignement sont des traits verticaux ou horizontaux qui traversent les limites d'un contrôle virtuel.

Quand les points d'alignement sont en place, vous pouvez fournir les informations sur les directives de l'UI de façon à ce que chaque composant respecte les prescriptions s'appliquant, par exemple, à la distance entre les contrôles, aux raccourcis, aux libellés prenant la focalisation, à l'ordre de tabulation, au nombre maximal d'éléments (zones de liste, menus), et ainsi de suite. De cette façon, le '''Concepteur de fiches''' peut assister le développeur de code dans l'adhésion aux directives établies sur l'UI.

Si l'option '''Accrocher à la grille''' est activée (sur {{Menu|Outils > Options > Interface utilisateur > [[Options du Concepteur de fiches|Concepteur de fiches]]}}), ainsi que '''Utiliser les directives du concepteur''', les directives du concepteur sont prioritaires. Cela signifie que si un point de la grille se trouve dans la tolérance du nouvel emplacement et qu'une directive se trouve également dans le voisinage, le contrôle respecte la directive et non la position sur la grille, même si la directive ne coïncide pas avec la position sur la grille. La tolérance d'alignement est déterminée par la taille de la grille. Même si les options '''Accrocher à la grille''' et '''Afficher la grille''' sont désactivées, le Concepteur détermine la tolérance en fonction de la taille de la grille.

==Palette d'outils==

La '''[[Palette d'outils|Palette d'outils]]''', située sur la colonne de droite, contient des éléments qui vous permettent de développer votre application. Les éléments affichés dépendent de la vue en cours. Par exemple, si vous affichez une fiche sur le concepteur, la '''palette d'outils''' affiche les composants appropriés à cette fiche. Double-cliquez sur un contrôle pour l'ajouter à votre fiche. Vous pouvez aussi le faire glisser vers une position désirée de la fiche. Si vous visualisez du code dans '''l'éditeur de code''', la '''palette d'outils''' affiche des segments de code que vous pouvez ajouter à votre application.

===Composants personnalisés===

Outre les composants qui sont installés avec {{Variables|Product}}, vous pouvez ajouter des composants personnalisés ou tiers à '''la palette d'outils''' et les enregistrer dans leur propre catégorie.

===Templates de composants===

Vous pouvez créer des templates composés d'un ou de plusieurs composants. Après avoir organisé les composants sur une fiche, défini leurs propriétés et écrit du code pour eux, vous pouvez les enregistrer sous la forme d'un template de composant. Par la suite, en sélectionnant le template dans '''la palette d'outils''', vous pouvez placer les composants préconfigurés sur une fiche en une seule étape ; toutes les propriétés et tout le code de gestion d'événement associés sont simultanément ajoutés à votre projet. Vous pouvez repositionner les composants indépendamment les uns des autres, réinitialiser leurs propriétés, et créer ou modifier des gestionnaires d'événements comme si vous aviez positionné chaque composant séparément.
{{f|componenttoolbar|2=

==Barre d'outils des composants==

La '''[[Barre d'outils des composants|Barre d'outils des composants]]''' contient toutes les catégories et tous les composants qui apparaissent sur la '''palette d'outils''' régulière (Standard, Accès aux données, et ainsi de suite). Toutefois, la '''barre d'outils des composants''' affiche les catégories de composants sous la forme d'un ensemble d'onglets situé sur la barre d'outils au sommet de la fenêtre de l'EDI, similaire à {{Delphi|7}} {{Version|7}} et {{CBuilder|6}} {{Version|6}}. Cliquez sur un onglet de la barre d'outils des composants pour afficher les icônes des composants de cette catégorie. Cliquez ensuite sur une icône pour sélectionner un composant.

Quand la '''barre d'outils des composants''' est activée, la '''palette d'outils''' est aussi disponible, et vous pouvez utiliser la '''barre d'outils des composants''' ou la '''palette d'outils''' pour ajouter des composants à votre application. Voir [[Activation de la barre d'outils des composants|Activation de la barre d'outils des composants]].

Pour de plus amples informations sur les différentes barres d'outils disponibles dans l'EDI, voir '''[[Barres d'outils|Barres d'outils]]'''.
}}

==Inspecteur d'objets==

'''
[[Inspecteur d'objets|L'inspecteur d'objets]]''', situé sur la gauche, vous permet de définir les propriétés de conception et de créer des gestionnaires d'événements pour vos composants. Il fournit la connexion entre l'apparence visuelle de votre application et le code qui lui permet de fonctionner. '''L'inspecteur d'objets''' contient deux onglets : '''Propriétés''' et '''Evénements'''.

Utilisez l'onglet '''Propriétés''' pour modifier les attributs physiques des composants. Selon votre sélection, certaines catégories d'options vous permettent d'entrer une valeur dans une zone de texte, alors que d'autres attendent que vous sélectionniez une valeur dans une liste déroulante. Pour les opérations booléennes, vous passez de True à False, et vice-versa. Après avoir modifié les attributs physiques de vos composants, vous créez des gestionnaires d'événements qui gèrent les composants.

Utilisez l'onglet '''Evénements''' pour spécifier les événements d'un objet spécifique que vous sélectionnez. S'il existe un gestionnaire d'événement, utilisez la liste déroulante pour le sélectionner. Par défaut, certaines options de '''l'inspecteur d'objets''' sont repliées. Pour développer les options, cliquez sur le signe plus (+) en regard de la catégorie.

Certains composants non visuels, comme les fournisseurs de données Borland offrent un accès rapide à des éditeurs comme '''l'éditeur de connexion''' et '''l'éditeur de texte de commande'''. Vous pouvez accéder à ces éditeurs dans la zone '''Verbe du concepteur''' en bas de '''l'inspecteur d'objets'''. Pour ouvrir les éditeurs, placez votre curseur sur le nom de l'éditeur jusqu'à ce que le curseur prenne la forme d'une main et l'éditeur se change en un lien. Vous pouvez aussi cliquer avec le bouton droit sur le composant non visuel et défiler jusqu'à l'éditeur associé et le sélectionner. Sachez que les composants non visuels n'ont pas tous d'éditeur associé. En plus des éditeurs, cette zone peut aussi afficher des hyperliens pour montrer des éditeurs de composants personnalisés, lancer une page web et afficher des boîtes de dialogue.

==Référentiel d'objets==

Pour simplifier le développement, {{Variables|Product}} propose des templates prédéfinis, des fiches et d'autres éléments auxquels vous avez accès et que vous pouvez utiliser dans vos applications.

===Contenu du référentiel d'objets===

Le '''[[Référentiel d'objets|Référentiel d'objets]]''' contient des éléments qui correspondent aux types d'applications que vous pouvez développer. Il contient des templates, des fiches et bien d'autres éléments. Vous pouvez créer des projets tels qu'une bibliothèque de classes, une bibliothèque de contrôles, des applications console et autres en accédant aux templates disponibles.

Pour ouvrir le '''référentiel d'objets''', choisissez <font color="#598527">'''Fichier > Nouveau > Autre'''</font>. La boîte de dialogue '''Nouveaux éléments''' affiche le contenu du '''référentiel d’objets'''. Vous pouvez aussi modifier ou retirer des objets existants du '''référentiel d'objets''' en cliquant avec le bouton droit dans le '''référentiel d'objets''' afin d'afficher les options d'édition.

===Templates du référentiel d'objets===

Vous pouvez ajouter vos propres objets au '''référentiel d'objets''' en tant que templates que vous réutilisez ou partagez avec d'autres développeurs. La réutilisation d'objets vous permet de concevoir des familles d'applications ayant une interface utilisateur et des fonctionnalités communes, afin de réduire les temps de développement et d'améliorer la qualité.

Vous pouvez ajouter dans le '''référentiel d'objets''' un projet de démarrage, une démo, un template ou tout autre fichier utile et le rendre accessible depuis le menu Nouveau. Choisissez <font color="#598527">'''Projet > Ajouter au référentiel'''</font>. Sélectionnez votre fichier. Ensuite, lorsque vous sélectionnez la commande <font color="#598527">'''Fichier > Nouveau'''</font>, vous pouvez choisir le fichier que vous venez d'ajouter et en utiliser un nouvel exemplaire.

{{Variables|Product}} vous permet de créer plusieurs bibliothèques de templates personnalisées servant de base à la création de futurs projets. Les bibliothèques de templates vous permettent de définir l'apparence des projets et d'ajouter de nouveaux types de projets dans le '''référentiel d'objets'''.

==Gestionnaire de projets==

Un '''projet''' est constitué de plusieurs fichiers d'application. La '''[[Fenêtre Projets|Fenêtre Projets]]''', située dans la colonne supérieure droite, permet de visualiser et d'organiser les fichiers de votre projet, comme les fiches, les exécutables, les assemblages, les objets et les fichiers bibliothèque. Dans le '''Gestionnaire de projets''', vous pouvez ajouter, retirer et renommer des fichiers en utilisant la barre d'outils ou le menu contextuel. Vous pouvez même appeler la boîte de dialogue Options de projet depuis le menu contextuel du '''Gestionnaire de projets'''.

===Groupes de projets===

Vous pouvez combiner des projets associés pour former un '''groupe de projets'''. Pour ce faire, cliquez avec le bouton droit sur le noeud groupe de projets par défaut ([[File:Project Group.png]]) dans le '''Gestionnaire de projets''' et sélectionnez '''[[Ajouter un nouveau projet|Ajouter un nouveau projet]]''' ou '''Ajouter un projet existant'''. La liaison de plusieurs projets en un groupe de projets vous permet de compiler le groupe de projets entier en une seule fois. Mais vous pouvez aussi compiler tout projet unique en cliquant avec le bouton droit sur un noeud de projet et en sélectionnant une des commandes de compilation ou de construction sur le menu contextuel.

Après la création délibérée d'un groupe de projets, vous êtes invité à enregistrer le fichier <code>.groupproj</code> quand vous quittez l'EDI ou entrez une commande d'enregistrement pour un des projets inclus. Vous pouvez aussi enregistrer explicitement un groupe de projets en utilisant les commandes du menu contextuel.

==Explorateur de données==

'''
[[Explorateur de données|L'explorateur de données]]''' permet de parcourir des objets de schéma spécifiques au serveur de base de données, notamment les tables, les champs, les définitions de procédures stockées, les déclencheurs et les index. Les menus contextuels vous permettent de créer et de gérer les connexions aux bases de données. Vous pouvez aussi faire glisser et déposer des données depuis une source de données vers la plupart des fiches pour construire rapidement votre application de base de données.

==Vue Structure==

La '''[[Vue Structure|Vue Structure]]''' présente la hiérarchie du code source ou le langage HTML affiché dans '''l'éditeur de code''', ou les composants affichés sur le concepteur. Si la vue affiche la structure du code source ou le langage HTML, vous pouvez double-cliquer sur un élément pour accéder à sa déclaration ou à son emplacement dans '''l'éditeur de code'''. Si la vue affiche des composants, vous pouvez double-cliquer sur un composant pour le sélectionner sur la fiche.

Si votre code contient des erreurs de syntaxe, elles s'affichent dans le dossier '''Erreurs''' de la vue '''Structure'''. Double-cliquez sur une erreur pour localiser sa source dans '''l'éditeur de code'''.

Vous pouvez contrôler le contenu et l'aspect de la '''vue Structure''' en choisissant {{Menu| Outils > Options > Interface utilisateur > [[Structure|Structure]]}}, puis en modifiant les paramètres.

==[[Audit de code intelligent|Fenêtre de chat IA]]==

La fenêtre de chat IA est une fiche ancrable de l'EDI, qui fonctionne comme n'importe quelle fenêtre de chat LLM. Vous pouvez taper une requête, choisir un moteur et attendre la réponse.

Pour pouvoir utiliser cette fonctionnalité, vous devez toutefois l'activer dans l'option [[Options relatives à l'audit de code intelligent|Audit de code intelligent]].

==Gestionnaire de l'historique==

Le '''[[Gestionnaire de l'historique|Gestionnaire de l'historique]]''', situé dans le volet central, vous permet de voir et de comparer les versions d'un fichier, y compris les diverses versions sauvegardées, les modifications enregistrées localement et le tampon mémoire des modifications non enregistrées d'un fichier actif. Si le fichier en cours est sous contrôle de version, tous les types des révisions sont disponibles dans le '''gestionnaire de l'historique'''.

'''
[[Intégration de Subversion dans l'EDI|L'intégration de Subversion dans l'EDI]]''' est implémentée sur le '''gestionnaire de l'historique''', qui affiche les informations Subversion chaque fois qu'elles sont disponibles dans le système de fichiers.

Le '''gestionnaire de l'historique''' se trouve à droite de l'onglet '''Code''' et contient les pages à onglets suivantes :

*La page '''Contenu''' affiche les versions actuelle et précédente du fichier.
*La page '''Diff''' affiche les différences entre les versions sélectionnées du fichier.
*La page '''Info''' affiche tous les libellés et commentaires associés au fichier actif.

Vous pouvez utiliser la barre d'outils du '''gestionnaire de l'historique''' pour actualiser les informations de révision, rétablir une version sélectionnée à la version la plus actuelle et synchroniser le défilement entre les visualiseurs source de la page '''Contenu''' ou '''Diff''', et '''l'éditeur de code''', et pour la navigation de fenêtre (comme Aller à la différence suivante).

==Editeur de code==

'''
[[Editeur de code|L'éditeur de code]]''', situé dans le volet central, propose un moyen pratique de visualiser et de modifier le code source. C'est un éditeur UTF8 complet et personnalisable qui comprend entre autres les sauvegardes automatiques, l'audit de code, la mise en surbrillance syntaxique, de multiples capacités d'annulation, l'aide contextuelle, les templates dynamiques, la saisie semi-automatique de blocs (achèvement de bloc), la recherche de classe, la recherche d'unités et l'importation d'un espace de nommage.

==Débogueur==

Les débogueurs intégrés vous permettent de trouver et de corriger les erreurs d'exécution et de logique dans votre application {{Variables|Product}}. En utilisant les débogueurs, vous pouvez parcourir le code pas à pas, définir des points d'arrêt et de suivi et inspecter ou modifier les valeurs du programme. Quand vous déboguez votre application, les [[Fenêtres de débogage - Index|fenêtres de débogage]] sont disponibles pour vous aider à gérer la session de débogage et vous donnent des informations sur l'état de votre application.

==Voir aussi==

*[[Aperçu et page d'accueil|Aperçu et page d'accueil]]
*[[Référence EDI et utilitaires|Référence EDI et utilitaires]]
*[[Démarrage d'un projet - Présentation|Démarrage d'un projet - Présentation]]
*[[Enregistrement des dispositions du bureau|Enregistrement des dispositions du bureau]]
*[[Concepteur de fiches|Concepteur de fiches]]
*[[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]]
*[[Editeur de code|Editeur de code]]
*[[Personnalisation de l'éditeur de code|Personnalisation de l'éditeur de code]]
*[[Fractionnement de l'éditeur|Fractionnement de l'éditeur]]
*[[Débogage des applications - Index|Débogage des applications]]
*[[Utilisation du Gestionnaire de l'historique|Utilisation du Gestionnaire de l'historique]]
*[[Rubriques de l'explorateur de classes Delphi|Rubriques de l'explorateur de classes Delphi]]
*[[Rubriques de l'explorateur de classes C++|Rubriques de l'explorateur de classes C++]]

[[Category:Prise en main]]
[[Category:AMMigrate]]

WebStencils

Yukikoi — Fri, 09 Oct 2026 17:05:25 GMT

Yukikoi a importé WebStencils par téléversement de fichier (1 version) LOC-23451

Nouvelle page

WebStencils, un système d'intégration et de traitement des fichiers HTML côté serveur, a été introduit dans {{Product}} version 12.2 pour les technologies WebBroker et RAD Server. Cette fonctionnalité flexible permet aux développeurs de concevoir des sites web modernes basés sur n'importe quelle bibliothèque JavaScript tout en exploitant les données extraites et traitées par une application serveur RAD Studio. Cette technologie offre une grande flexibilité pour créer des sites web adaptés à vos besoins spécifiques.

WebStencils a pour objectif de faciliter la création de sites de navigation par l'adoption des technologies Web (WebBroker, DataSnap, RAD Server) en fournissant des scripts côté serveur. Il est ainsi possible de générer des pages HTML avec des outils standard et d'utiliser n'importe quelle bibliothèque CSS et JavaScript tout en ajoutant des données à partir des pages générées depuis l'application (il peut s'agir par exemple du résultat d'une requête de base de données).

De plus, WebStencils constitue une excellente base pour le développement Web avec HTMX. Les pages HTMX bénéficient de la génération de code côté serveur et peuvent se connecter à des serveurs REST pour la mise à jour du contenu. Les technologies Web de Delphi offrent des fonctionnalités de génération de page et d'API REST de très haut niveau.

==Syntaxe de WebStencil==

Le langage de script de WebStencils repose sur deux éléments et est relativement simple :

* Le {{code|'''@''' }}
* Les accolades {{code| '''{ }''' }}

===Utilisation du symbole {{code|@}}===

WebStencils utilise le symbole {{code|'''@'''}} comme marqueur spécial plutôt que des balises HTML/XML ou d'autres notations. Le symbole {{code|'''@'''}} est suivi par :

* Le nom d'un objet ou d'un champ.
* Un [[WebStencils#Mots clé de WebStencils|mot clé spécial]].
* Un autre symbole {{code|'''@'''}}. {{Tip| L'utilisation du symbole {{code|'''@'''}} est plus souple. Ainsi, vous n'aurez pas besoin de le doubler dans certaines situations, comme dans les en-têtes.}}

L'accès général à une valeur est basé sur une notation par point, sous la forme object.value. C'est pourquoi vous observerez des balises comme :

@object.value

Le nom de '''l'objet''' est un nom symbolique local qui peut correspondre à un objet réel d'une application serveur, assigné à l'exécution du script via un processus de recensement. Il peut aussi être résolu dans le code lors du traitement d'un gestionnaire d'événement OnGetValue.

La valeur est composée du nom de la propriété (pour un objet générique), du nom d'un champ (si l'objet hérite de TDataSet), et d'une chaîne qui est transmise dans le gestionnaire d'événement OnGetValue associé au processeur.

{{Note|La sortie des valeurs traitées par WebStencils est chiffrée avec la méthode TNetEncoding.HTML.Encode. Vous pouvez supprimer le chiffrement en utilisant la syntaxe {{code|@\value}}.}}

====Accès aux ensembles de données et objets imbriqués====

Vous pouvez aussi utiliser le symbole {{code|'''@'''}} pour accéder à des ensembles de données et des objets imbriqués en utilisant la syntaxe suggérée dans les scénarios suivants :

* Objets et classes imbriqués :<source lang="delphi">
@MyObject.SubObject.ProperyName</source>
* Tables dans les ensembles de données imbriqués :<source lang="delphi">
@MyDataSet.DataSetField.SubField</source>

===Utilisation des accolades pour les blocs {{code|{}}}===

La seconde notation utilise des accolades, {{code|{}} et {{code|}}}, pour indiquer les blocs conditionnels ou répétés.

Toute autre utilisation des accolades dans le fichier de code source (le fichier HTML) est ignorée. En d'autres termes, les accolades ne sont traitées que si elles sont utilisées après une instruction conditionnelle WebStencils spécifique.

===Accès à des valeurs avec la notation par point===

Prenons en exemple l'extrait de code HTML WebStencils ci-dessous :<source lang="delphi">
<h2>GetValue</h2>
<p>Value obtained from data: @data.name</p>
<p>Value obtained with request @@data.value: @data.value</p></source>

Les symboles {{code|@@}} sont ignorés (nous attendons un seul {{code|@}} en sortie). Il suffit d'un seul pour déclencher le traitement.
Notez également que les deux symboles, le nom d'objet et le nom de valeur, doivent être des identificateurs Delphi valides et ne peuvent pas contenir d'espaces ni commencer par un chiffre. Un nom peut contenir des caractères de soulignement et des chiffres.

===Gestionnaire d'événement OnValue===

Il est possible de fournir des données en utilisant un composant avec le gestionnaire d'événement OnValue. Par exemple :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebStencilsValueFromEventValue(Sender: TObject;
const ObjectName, FieldName: string; var ReplaceText: string;
var Handled: Boolean)
begin
if SameText (ObjectName, 'data') then
begin
Handled := True;
ReplaceText := 'You requested ' + FieldName;
end;
end;</source>

Dans le code exemple ci-dessus, le code vérifie uniquement le nom d'objet (la première partie du symbole avant le point), mais il est recommandé de vérifier également la propriété FieldName (le symbole après le point).

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebStencilsValueFromEventValue(TObject *Sender,
const String ObjectName, const String FieldName, String &ReplaceText, bool &Handled)
{
if (SameText(ObjectName, "data"))
{
Handled = true;
ReplaceText = "You requested " + FieldName;
}
}</source>

Dans l'exemple ci-dessus, {{code|String}} est une chaîne {{code|UnicodeString}} compatible Delphi dans C++ Builder. {{code|SameText}} est une fonction de comparaison de chaînes insensible à la casse fournie par SysUtils. Enfin, {{code|&ReplaceText}} et {{code|&Handled}} sont transmis par référence pour permettre la modification et reproduire le comportement {{code|var}} de Delphi.

===Utilisation d'un objet dans le dictionnaire de variables de script===

Une autre approche consiste à fournir les valeurs en utilisant un objet. Dans ce cas, l'objet doit être configuré et associé à l'action du producteur.

Voici un exemple complet, supposant une classe TMyObject et sa propriété Name :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule1.WebModule1WebActionItem2Action(Sender: TObject;
Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
begin
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetValue</h2>
<p>Value obtained from data: @world.Name</p>
''';
var MyObj := TMyObject.Create();
MyObj.Name := 'Hello hello';
WebStencilsProcessor1.AddVar('world', MyObj, True);
Response.Content := WebStencilsProcessor1.Content;
Handled := True;
end;</source>

Cet exemple donne le résultat suivant :

"Value obtained from data: Hello Hello"

Notez que l'objet est recensé avec le nom 'world', qui sera ensuite utilisé dans le script WebStencils.

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule1::WebModule1WebActionItem2Action(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
WebStencilsProcessor1->InputLines->Text =
"<h2>GetValue</h2>\n"
"<p>Value obtained from data: @world.Name</p>";

TMyObject *MyObj = new TMyObject();
MyObj->Name = "Hello hello";

WebStencilsProcessor1->AddVar("world", MyObj, true);

Response->Content = WebStencilsProcessor1->Content;
Handled = true;
}</source>

===Expressions===

Voici la liste des expressions prises en charge :

*{{code|'''@ (<expression>)'''}} - marqueurs de variable. L'expression doit être écrite entre parenthèses.
*{{code|'''@if (<expression>)'''}} - commande "if". L'expression doit être écrite entre parenthèses.
*{{code|'''@Import (<expression>)'''}}, {{code|'''@LayoutPage (<expression>)'''}}, {{code|'''@AddPage (<expression>)'''}} - ''commandes de fichier. L'expression doit être écrite entre accolades.''

L'exemple suivant montre uniquement les différences entre les options ci-dessus :<source lang="delphi">
WebStencilsProcessor1.InputLines.Text := '''
<h2>GetExpression</h2>
<p>Value obtained from data: @(world.value*2)</p>
''';
MyObj.Value := 2;</source>

Vous obtenez alors la sortie suivante :

"Value obtained from data: 4"

En plus des expressions simples, vous pouvez étendre le système en utilisant des appels de fonction personnalisés. Voici un exemple de code qui recense une fonction “'''Concat'''” recevant deux paramètres chaîne :<br />'''Delphi :'''<source lang="delphi">
uses
System.Bindings.EvalProtocol, System.Bindings.Methods;

TBindingMethodsFactory.RegisterMethod(
TMethodDescription.Create(
MakeInvokable(function(Args: TArray<IValue>): IValue
begin
Result := TValueWrapper.Create(
Args[0].GetValue.AsString + Args[1].GetValue.AsString);
end),
'Concat', 'Concat', '', True, '', nil));</source>

Dans un script WebStencils, vous pouvez l'utiliser dans une expression comme :

@(Concat('aaa', 'bbb']]

'''C++ :'''<source lang="cpp">
#include <System.Bindings.EvalProtocol.hpp>
#include <System.Bindings.Methods.hpp>
#include <System.Rtti.hpp>
#include <System.SysUtils.hpp>

using namespace System::Bindings::EvalProtocol;
using namespace System::Bindings::Methods;
using namespace System::Rtti;

class TValueWrapper : public TInterfacedObject, public IValue
{
private:
TValue FValue;

public:
__fastcall TValueWrapper(const TValue &AValue) : FValue(AValue) {}

virtual TValue __fastcall GetValue() { return FValue; }

// Implement other IValue methods as needed...
};

void RegisterCustomBindingMethod()
{
TBindingMethodsFactory::RegisterMethod(
new TMethodDescription(
MakeInvokable([](const TArray<IValue*> &Args) -> IValue*
{
String s1 = Args[0]->GetValue().ToString();
String s2 = Args[1]->GetValue().ToString();
return new TValueWrapper(TValue::From<String>(s1 + s2));
}),
"Concat", "Concat", "", true, "", nullptr));
}</source>

====Instruction Switch====

En plus de l'instruction {{code|@if}}, les utilisateurs peuvent choisir d'utiliser les instructions {{code|@switch}} ou {{code|@case}}.<br />
Voici un exemple de syntaxe :<source>
@switch(@user.role) {
@case "admin" {
<div>Admin Panel</div>
} @case "moderator" {
<div>Moderator Tools</div>
} @default {
<div>Regular User View</div>
}
}</source>

A partir de l'exemple ci-dessus, notez que :

*Les valeurs des "case" peuvent être des littéraux ou des expressions utilisant {{code|@}}(expression).
*Seul le premier "case" correspondant est exécuté.
*L'utilisation de {{code|@default}} est facultative et s'exécute s'il n'y a pas de correspondance avec "case"'.

===Utilisation d'un ensemble de données===

Une alternative consiste à utiliser l'enregistrement en cours d'un ensemble de données plutôt qu'un objet. Dans ce cas, votre code sera comme suit :<br />'''Delphi :'''<source lang="delphi">
procedure TWebModule13.WebModule13waCompanyAction(Sender: TObject;
Request: TWebRequest; Response: TWebResponse;
var Handled: Boolean];
begin
ClientDataSet1.Open;
if not WebStencilsValueFromObject.InVars ('dataset'] then
WebStencilsValueFromObject.AddVar(
'dataset', ClientDataSet1, False]; // False = do not destroy
Response.Content := WebStencilsValueFromObject.Content;
ClientDataSet1.Close;
end;</source>

'''C++ :'''<source lang="cpp">
void __fastcall TWebModule13::WebModule13waCompanyAction(TObject *Sender,
TWebRequest *Request, TWebResponse *Response, bool &Handled)
{
ClientDataSet1->Open();

if (!WebStencilsValueFromObject->InVars("dataset"))
{
WebStencilsValueFromObject->AddVar("dataset", ClientDataSet1, false); // false = do not destroy
}

Response->Content = WebStencilsValueFromObject->Content;

ClientDataSet1->Close();
}</source>

Le code HTML correspondant peut contenir des références à certains champs de l'enregistrement. Voici un exemple de résultat :<source lang="delphi">
<div class="list-group w-50">
@foreach dataset {
<a href="/company?id=@loop.custno" class="list-group-item
list-group-item-action" aria-current="true">
<div class="d-flex w-100 justify-content-between">
<h5 class="mb-1">@loop.company</h5>
<small>@loop.country</small>
</div>
<p class="mb-1">@loop.city</p>
<small>@loop.state</small>
</a>
}</source>

====Accès aux propriétés de l'ensemble de données====

La notation WebStencils {{code|@}} relative à un ensemble de données permet d'accéder aux propriétés de l'ensemble de données, en plus de ses champs. Les utilisateurs peuvent utiliser {{code|@data.RecordCount}} pour accéder à la propriété RecordCount. En cas de conflit, les champs de l'ensemble de données ont priorité sur les propriétés portant le même nom.

Cela inclut l'accès aux informations des champs, comme suit :

@foreach field in customers.fields

Ainsi que l'accès aux propriétés des champs :<source>
@foreach customer in customers {
@customer.address.visible
@customer.phone.displaylabel
}</source>

==Utilisation de variables de modules==

Alternativement, pour recenser un objet spécifique pour un WebStencilsProcessor, vous pouvez ajouter un “'''module'''” avec plusieurs objets. Dans ce contexte, un 'module' est une collection d'objets ou de fonctions liés entre eux. N'importe quel champ ou n'importe quelle propriété du module peut être décoré avec l'attribut {{code|'''[WebStencilsVar]'''}}, qui vous permet de spécifier comment le WebStencilsProcessor doit traiter les données.

Par exemple, supposons que votre module de données a un composant FDMemTable1 de type TFDMemTable marqué comme {{code|'''[WebStencilsVar]'''}}, et un champ LastName, vous pouvez écrire :

<source lang="delphi">

WebStencilsProcessor1.InputLines.Text := '''
<h2>GetTableData</h2>
<p>Value obtained from table: @(FDMemTable1.LastName)</p>
''';
WebStencilsProcessor1.AddModule(self);</source>L'exemple ci-dessous renvoie la valeur de LastName dans le premier enregistrement. Utilisez une boucle {{code|'''@for'''}} pour afficher tous les enregistrements.

===Utilisation de variables supplémentaires===

Ajoutez des variables supplémentaires au moteur de script à l'extérieur des modèles d'objet et d'ensemble de données. Plutôt que d'ajouter une structure de données spécifique, ce mécanisme propose une méthode anonyme qui permet d'implémenter une recherche personnalisée dans une structure de données personnalisée. Il s'agit des méthodes suivantes :

TWebStencilsDataVars.Add(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsProcessor.AddVar(LookupFunc), AddInitFunc(LookupFunc)
TWebStencilsEngine.AddVar(LookupFunc), AddInitFunc(LookupFunc)

Voici un exemple :

<source lang="delphi">
type
TMap = TDictionary<string, string>;
var
LDict: TMap;
begin
LDict := TMap.Create;
LDict.Add('APP_VERSION', '1.0.0');
LDict.Add('APP_NAME', 'WebStencils demo');
LDict.Add('COMPANY_NAME', 'Embarcadero Inc.');
LDict.Add('DEBUG_MODE', 'True');

FWebStencilsProcessor.AddVar('env', LDict, True,
function(AVar: TWebStencilsDataVar; const APropName: string;
var AValue: string): Boolean
begin
Result := TMap(AVar.TheObject).TryGetValue(APropName.ToUpper, AValue);
end);</source>

Vous pouvez aussi l'utiliser dans un modèle, comme suit :

<source>
@env.APP_NAME - @env.APP_VERSION
@if env.DEBUG_MODE {
<div>Debug mode active</div>
}</source>

==Mots clés de WebStencil==

Le moteur WebStencils utilise les balises suivantes sous forme de mots clés (notez que ces noms ne peuvent pas être utilisés pour des variables de script).

{| class="wikitable"
|-
!Mot clé
!Description
|-
|{{code| '''@query'''}}
|Utilisé pour lire des paramètres de requête HTTP.
|-
|{{code| '''@page'''}}
|Fournit l'accès au nom de la page et aux arguments de l'URL (voir la propriété [[WebStencils#Utilisation de WebStencils avec RAD Server|PathTemplate]] pour plus d'informations). Il est possible d'accéder au chemin de l'URL en utilisant l'une de ces valeurs :
*{{code|@page.request_path}}
*{{code|@page.request_segment}}
|-
|{{code| '''@lang'''}}
|Utilisé pour la prise en charge de la traduction, déclenche un événement OnLang distinct plutôt que l'événement OnValue.
|-
|{{code| '''@* .. *@'''}}
|Utilisé pour ajouter des commentaires dans le script, qui seront omis dans le HTML résultant.
|-
|{{code| '''@if'''}} object.value { … } ['''@else''' { … }]
|Exécute le bloc suivant entre accolades uniquement si la valeur vaut {{code|true}}.
|-
|{{code| '''@if (<expression>)'''}}
|Utilisé pour restituer du contenu de façon conditionnelle. Si l'expression est évaluée à {{code|true}}, le contenu associé est inclus dans la sortie ; sinon il est omis.
|-
|{{code| '''@if not''' object.value { ... } ['''@else''' { … }]}}
|Exécute le bloc suivant entre accolades uniquement si la valeur ne vaut pas {{code|true}}. <br />Par exemple :
<source lang="delphi">
@if obj1.ValueBelowTen {
<p>@obj1.name <span> has a value of </span> @obj1.value</p>
}</source>
|-
|{{code| '''@ForEach''' (var object in list) { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement :
*Les ensembles de données
*TObjectList, doit être ajouté au dictionnaire de processeur.
*Tout objet possédant la méthode GetEnumerator, où l'énumérateur renvoie une valeur d'objet.
|-
|{{code| '''@ForEach''' object { … }}}
|Exécute le bloc entre accolades suivant aussi souvent qu'il y a d'éléments dans l'énumérateur. <br />Supporte actuellement les ensembles de données et TObjectList, qui doivent être ajoutés en tant que variables de script.
|-
|{{code|'''@loop'''}}
|Utilisez à l'intérieur d'un bloc pour faire référence à l'élément en cours de l'énumération (liste ou ensemble de données). Il doit être suivi du nom d'une propriété ou d'un champ sans utiliser de nom d'objet.
|-
|{{code|'''@Import'''}}
|Permet de fusionner un fichier externe à un emplacement spécifique du fichier externe. Suppose toutefois que le nom de fichier ait l'extension .HTML. <br />Le format doit être comme suit :
<source lang="delphi">
@import filename [ {<alias1> = <var1> [..., <aliasN> = <varN>]} ]</source>
|-
|{{code|'''@Scaffolding'''}}
|Espace réservé pour le scaffolding. Ce mécanisme permet de générer dynamiquement du code HTML à partir de la structure de données d'une application (les propriétés d'un objet et les champs d'une base de données). Le code HTML généré côté serveur peut inclure d'autres balises pour accéder aux données. <br />Le code suivant est un exemple de disposition HTML simple générée dans le gestionnaire d'événement OnScaffolding pour chacun des champs de la base de données.
<source lang="delphi">
procedure TWebModule1.ProcessorCompanyScaffolding(Sender: TObject;
const AQualifClassName: string; var AReplaceText: string);
begin
if SameText (AQualifClassName, 'Company') then
begin
AReplaceText := '';
for var I := 0 to ClientDataSet1.Fields.Count -1 do
AReplaceText := AReplaceText + '<p>'+
ClientDataSet1.Fields[I].FieldName +
': @dataset.' + ClientDataSet1.Fields[I].FieldName + '</p>';
end;
end;</source>
|-
|{{code|'''@switch'''}}, {{code|'''@case'''}}, {{code|'''@default'''}}
|Effectue un rendu conditionnel à branches multiples. Après avoir évalué une expression, la met en correspondance avec les valeurs définies avec @case, en restituant le bloc correspondant. La directive @default est utilisée si aucune correspondance n'est trouvée pour @case.
|-
|{{code|'''@LoginRequired'''}}
|Arrête l'exécution si une connexion est requise alors que l'utilisateur n'est pas connecté.
|-
|{{code|'''@LoginRequired (<role>)'''}}
|Le moteur vérifie que l'utilisateur est connecté, mais aussi qu'il dispose du rôle spécifique actif, ce qui restreint l'accès à la page selon la permission.<br /> Par exemple : '''@LoginRequired (admin)'''
|}

===Alias d'importation===

L'exemple ci-dessous illustre comment utiliser des alias d'importation.<source lang="delphi">
@import one {@o1 = @object, @d1 = @data} Hello</source>

Dans ce code, '''@object''' et '''@data''' sont les véritables variables dans le script exécuté. Les alias '''@o1''' et '''@d1''' sont des variables de script pour le script "one" et sont accessibles dans ce script comme des variables normales. Ainsi, vous pouvez transmettre au script QA des variables portant des noms différents, en fournissant comme alias le nom attendu par le script.

==Modèles WebStencils : disposition et corps==

La capacité à fusionner un modèle HTML partagé avec le contenu d'une page compte parmi les fonctionnalités indispensables d'un moteur de modèle. Cette opération s'effectue (comme dans la version .NET) en utilisant quatre symboles spéciaux :

* '''@LayoutPage filename''' : cette commande est utilisée dans une page HTML spécifique (généralement en haut de page) pour indiquer le fichier de modèle à utiliser comme structure de la page. Plusieurs pages peuvent partager un même modèle, mais toutes les pages d'un projet (même en utilisant TWebStencilsEngine) ou d'un dossier virtuel n'ont pas nécessairement besoin d'utiliser le même modèle.

:{{Note| Cette commande ne doit être utilisée qu'une seule fois par page. Si vous tentez d'utiliser plusieurs fois '''@LayoutPage''', une exception se déclenche et bloque la commande.}}

* '''@RenderBody''' : cette commande sans paramètre est une marque de réservation dans un fichier de modèle qui indique où placer le contenu d'une page spécifique.

Voici un exemple d'utilisation de '''@LayoutPage''' et de '''@RenderBody''' :

'''Test.html'''<source lang="delphi">
@LayoutPage BaseTemplate
<h2>Page Test3</h2>
<p>Local data param one is @page.name (the page name)</p></source>

'''BaseTemplate.html'''<source lang="delphi">
<html lang="en">
<head>

@extends layouts/intermediate
@ExtraHeader {
<style>.highlight { color: green; }</style>
}


@extends layouts/base
@ExtraHeader {
<meta name="viewport" content="width=device-width, initial-scale=1">
}


<head>
@RenderHeader
</head></source>

Dans l'exemple ci-dessus, le CSS de {{code|page.html}} et la balise meta de {{code|intermediate.html}} sont injectés dans la sortie finale de {{code|@RenderHeader}}.

==Composants de WebStencils==

Le package WebStencils installe deux composants différents : un processeur de fichier unique et un moteur qui instancie des processeurs individuels et fournit une configuration globale pour les processeurs autonomes ou ceux auxquels ils sont manuellement connectés.

Le composant principal prend un fichier HTML, incorpore la notation WebStencils et le convertit en HTML brut après avoir traité les balises {{code|'''@'''}}.

La classe '''TWebStencilsProcessor''' traite un fichier individuel (généralement ayant une extension HTML) et son modèle associé, le cas échéant. Le processeur peut être utilisé de façon autonome et assigné au '''TWebActionItem.Producer''', ou être créé et appelé par TWebStencilsEngine en tant que post-processeur de fichiers texte renvoyés par un répartiteur de fichiers.

===Composant WebStencilsEngine===

Le composant '''Engine''' peut être utilisé dans les deux scénarios suivants :

*Pour le connecter à un ou plusieurs composants '''WebStencilsProcessor''' et fournir des comportements et des paramètres partagés.
*Pour créer des composants '''WebStencilsProcessor''' lorsque cela est nécessaire, et placer uniquement ce composant sur vos modules web.

==Intégration automatique de sessions==

Lorsqu'elles sont disponibles, [[WebStencils|WebStencils]] peut automatiquement s'intégrer à des sessions web. Aucune configuration supplémentaire n'est nécessaire. Tout se fait automatiquement dès lors que {{code|WebRequest.Sessions}} existe.

Les données des sessions sont accessibles via {{code|@session.property}}. Tous les objets dans {{code|WebRequest.Session.DataVars}} sont automatiquement recensés en tant que variables de modèles. De même, {{code|UserLoggedIn}} et {{code|UserRoles}} sont automatiquement remplis à partir de {{code|WebRequest.Session.User}}.

En voici un exemple :<source>
@if session.Authenticated {
<div>User authenticated</div>
@session.sessionid
}

@if session.UserHasRole(‘admin’) {
<div>User is an Admin</div>
}</source>

==Liste blanche de sécurité==

Pour des raisons de sécurité, WebStencils implémente un mécanisme de liste blanche de propriétés pour éviter l'exposition d'informations sensibles comme les chaînes de connexion aux bases de données. Par défaut, seules les propriétés sécurisées sont accessibles. Voici la liste des propriétés sécurisées :

*Pour les '''TDataSet''' : Active, FieldByName, First, Last, Next, Prior, Bof, Eof, FieldCount, Fields, Found, RecordCount, RecNo.
*Pour les '''TStrings''' : Contains, ContainsName, IndexOf, IndexOfName, CommaText, Count, IsEmpty, DelimitedText, Names, KeyNames, Values, ValueFromIndex, Strings, Text.

===Personnalisation de la liste blanche===

La liste blanche peut être personnalisée en utilisant la propriété [[lib_fr:Web.Stencils.TWebStencilsProcessor.Whitelist|TWebStencilsProcessor.Whitelist]]. La méthode de configuration permet aux utilisateurs de spécifier les membres autorisés et ceux bloqués. Voir l'exemple ci-dessous :<source>
procedure Configure(const AClass: <PTypeInfo, TClass, TObject>;
const AAllowedMembers: TArray<string>;
const ABlockedMembers: TArray<string>;
AReset: Boolean);</source>

* '''AClass''' : le type PTypeInfo/TClass/TObject pour configurer des éléments tels que des TDataSet, TStrings.
* '''AAllowedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite autoriser.
* '''ABlockedMembers''' : un tableau de propriétés ou de noms de méthodes que l'utilisateur souhaite bloquer.
* '''AReset''' : {{code|True}} lorsqu'utilisé pour remplacer une liste blanche existante, ou {{code|False}} pour ajouter des éléments à la liste.

Voici un exemple qui illustre comment ajouter des membres autorisés supplémentaires à une liste blanche existante :<source>
TWebStencilsProcessor.Whitelist.Configure(TMyClass,
['CustomProp'], nil, False);</source>

Voici un exemple qui illustre comment remplacer la totalité d'une liste blanche (AReset = True) :<source>
TWebStencilsProcessor.Whitelist.Configure(TDataSet,
['RecordCount', 'RecNo'], nil, True);</source>

Voici un exemple qui illustre comment bloquer certains membres :<source>
TWebStencilsProcessor.Whitelist.Configure(MyObject,
nil, ['CustomProp'], False);</source>

La liste blanche s'applique à l'ensemble de l'application et à tous les WebStencils.

==Utilisation de WebStencils avec RAD Server==

La bibliothèque de modèles WebStencils peut aussi être utilisée dans une application RAD Server. Il est recommandé de combiner le composant ''TEMSFileResource''' existant avec un composant '''TWebStencilsEngine'''. Le premier permet de mapper le système de fichiers, alors que le second gère le mappage HTTP et le traitement des modèles. Les composants sont connectés en utilisant la propriété Dispatcher du moteur WebStencil.

L'exemple ci-dessous illustre la configuration nécessaire pour ajouter deux composants à un module web RAD Server :<source lang="delphi">
object html: TEMSFileResource
PathTemplate = '..\..\html\{filename}'
end
object WebStencilsEngine1: TWebStencilsEngine
Dispatcher = html
PathTemplates = <
item
Template = '/'
Redirect = '/test1.html'
end
item
Template = '/list'
Redirect = '/companylist.html'
end
item
Template = '/company'
OnPathInit = WebStencilsEngine1PathTemplates2PathInit
end
...>
end</source>

Les PathTemplates sont utilisés pour mapper les URL entrantes à des fichiers. En mode conception, la configuration se présente comme suit :

[[File:PathTemplates WebStencils.png|350px|=link]]

De plus, il est nécessaire de configurer le mappage de plus haut niveau dans le module de données :

<source lang="delphi">
type
[ResourceName('testfile')]
TTestfileResource1 = class(TDataModule)
[ResourceSuffix('./')]
[ResourceSuffix('get', './')]
[EndpointProduce('get', 'text/html')]
html: TEMSFileResource;</source>

Pour mapper plusieurs chemins différents (à la différence de l'exemple ci-dessus), ajoutez des composants '''TEMSFileResource'''. Le composant '''TWebStencilsEngine''' peut comporter un seul dispatcher dans la propriété correspondante. Pour associer davantage de dispatchers, utilisez le code suivant :

<source lang="delphi">
AddProcessor(html2, WebStencilsEngine1);</source>

==Voir aussi==

*[[Présentation de RAD Server|Présentation de RAD Server]]

Pragma alias

Yukikoi — Fri, 09 Oct 2026 17:05:25 GMT

Yukikoi a importé Pragma alias par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{DISPLAYTITLE:#pragma alias}}
{{Parent|Présentation des directives pragma - Index}}

==Syntaxe <span style="font-size: 60%">(voir [[Pseudo-grammaire|Pseudo-grammaire]])</span>==

'''Chaîne d'outils classique''' :

#pragma alias "aliasName" = "substituteName"

'''Chaîne d'outils Clang''' :<br />
la directive <code>#pragma alias</code> n'est pas supportée par les compilateurs [[BCC64X|BCC64X]] et [[Compilateurs Win32 améliorés par Clang|BCC32C]]. A la place, vous pouvez laisser un commentaire pour le lieur en procédant comme suit :<br />

#pragma comment(linker, "/alternatename:<name1><nowiki>=</nowiki><name2>")

==Description==

<code>#pragma alias</code> indique au lieur que deux noms d'identificateurs sont équivalents. Les deux identificateurs doivent être saisis entre guillemets. Sinon, un avertissement [[W8086 Utilisation incorrecte de l'alias pragma "NomAlias"="NomSubstitué" (C++)|W8086 Utilisation incorrecte de l'alias pragma "aliasName"="substituteName" (C++)]] est émis.

Les alias sont à présent gérés dans des unités distinctes, par deux fichiers .obj, un pour Unicode et un pour non-Unicode. Ces deux fichiers .obj font partie de la bibliothèque VCL.

Le <code>NomAlias</code> et le <code>NomSubstitué</code> sont injectés dans leur fichier .obj correspondant, exactement comme ils sont écrits à l'intérieur des guillemets. Le lieur recherche toutes les références à <code>NomAlias</code> et les lie au <code>NomSubstitué</code>.

{{Note| Les [[Fichier d'en-tête C++ (*.h, *.hpp)|fichiers .hpp]] générés depuis le code {{Delphi}} utilisent l'alias <code>#pragma</code> pour la gestion des identificateurs qui sont substantypés différemment dans {{Delphi}} et {{CBuilder}}.}}

[[Category:Référence C++]]
[[Category:C++]]

Fractionnement de l'éditeur

Yukikoi — Fri, 09 Oct 2026 17:05:25 GMT

Yukikoi a importé Fractionnement de l'éditeur par téléversement de fichier (1 version) LOC-23451

Nouvelle page

La vue [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] permet d’utiliser plusieurs éditeurs côte à côte, les uns au-dessus des autres, ou de façon combinée, le tout dans une même fenêtre. Cela inclut la possibilité de faire glisser des ensembles d'onglets vers des fenêtres flottantes, puis de les replacer dans l'EDI.
Elle permet aussi d'avoir plusieurs dispositions personnalisées et offre diverses possibilités de manipulation : disposition simple en deux colonnes, disposition sur plusieurs lignes, ou une configuration particulièrement adaptée à votre flux de travail.
Vous pouvez travailler en ayant plusieurs onglets ouverts, et ouvrir la même unité dans chacun de ces onglets. Vous pouvez aussi avoir plusieurs onglets ouverts : l'un avec le concepteur de fiche et plusieurs autres avec le code de l'unité correspondante. L'onglet contenant le concepteur de fiche peut aussi être déplacé.
Il n'y a '''aucune limite''' quant au nombre de vues fractionnées, que ce soit horizontalement ou verticalement.

===Utilisation du fractionnement de l'éditeur===

Vous pouvez accéder à la vue Fractionnement de l'éditeur en cliquant avec le bouton droit sur un onglet et en choisissant '''Fractionner >''' ou '''Déplacer >'''. Le fractionnement crée une nouvelle version de l'onglet sélectionné, et le déplacement provoque son ouverture à l'endroit sélectionné dans l'EDI.

[[File:Using-spliteditor.png|=link|400px|border]]

Les raccourcis suivants peuvent être utilisés pour les deux options :

*'''Fractionner en haut :''' Alt+Maj+T
*'''Fractionner en bas :''' Alt+Maj+B
*'''Fractionner à droite :''' Alt+Maj+R
*'''Fractionner à gauche :''' Alt+Maj+L
*'''Déplacer en haut :''' Ctrl+Alt+Maj+T
*'''Déplacer à gauche :''' Ctrl+Alt+Maj+L
*'''Déplacer à droite :''' Ctrl+Alt+Maj+R
*'''Déplacer en bas :''' Ctrl+Alt+Maj+B

Alternativement, vous pouvez utiliser [[Fractionnement de l'éditeur|Fractionnement de l'éditeur]] en faisant glisser un fichier de la vue Projets dans un onglet de l'éditeur. Vous pouvez aussi effectuer un clic droit sur le fichier du projet, puis sélectionner l'option '''Ouvrir dans''' et choisir l'onglet de l'éditeur dans lequel vous souhaitez ouvrir le fichier.

Lorsque deux onglets sont dans une fenêtre, chacun a une barre de titre.

Le fractionnement de l'éditeur vous permet de :

*Faire glisser un onglet de l'éditeur, ou un ensemble d'onglets, en faisant glisser la barre de titre et en l'ancrant sur n'importe quel côté de la fenêtre de l'EDI.
*Le faire glisser et l'ancrer sur n'importe côté de l'éditeur (gauche, droit, haut, bas).
*Le fusionner avec un ensemble d'onglets en le faisant glisser au centre d'un éditeur existant, y compris une fenêtre flottante d'onglets.
*Le faire glisser en dehors de sa propre fenêtre (soit un seul onglet ou un ensemble d'onglets).

La plupart des opérations peuvent être réalisées sur des onglets individuels. Il peut s'agir par exemple de déplacer un onglet entre des ensembles d'onglets ancrés en faisant glisser l'onglet individuel d'un emplacement à un autre.

Chaque ensemble d'onglets peut être déplacé à l'extérieur de sa propre fenêtre. Faites glisser la barre de titre pour le déplacer.
{{Tip| Vous pouvez appuyer sur Ctrl tout en faisant glisser l'ensemble d'onglets pour vous assurer qu'il ne s'ancre pas.}}

De la même façon, chaque fenêtre peut être ancrée à côté d'un autre ensemble d'onglets. Pour cela, vous devez faire glisser la barre de titre.

{{Note|La plupart des éditeurs/groupes disparaissent de la vue lorsqu'ils sont fermés. Toutefois, la fermeture du premier éditeur (celui qui était auparavant l'éditeur de la fenêtre principale) avec le bouton ‘X’ provoque la fermeture de tous les onglets qu'il contient. L'espace qu'il occupait reste ouvert, car l'éditeur original ne peut pas être fermé. Cela n'a aucune incidence tant que les groupes d'onglets ne sont pas fermés. Il n'y a aucun impact visible lorsque vous créez, déplacez ou ancrez les onglets dans vos tâches.}}

[[File:Split Editor Example.png|800px|]]

''C'est l'une des nombreuses façons de configurer la vue Fractionnement de l'éditeur. Elle comporte une fenêtre d'édition sur la gauche, deux à droite, et les volets sont masqués mais apparaissent lorsqu'ils sont survolés par la souris.''

===Concepteur et code===

Les vues Fractionnement de l'éditeur permettent de modifier un même fichier dans deux fenêtres d'édition affichées côte à côte, chacune affichant le même contenu de fichier. Lorsque vous tapez dans l'une et que vous faites défiler le texte jusqu'à un emplacement, le texte apparaît dans l'autre fenêtre. Vous pouvez faire défiler les deux fenêtres indépendamment l'une de l'autre, ce qui permet de modifier le fichier à plusieurs endroits.
Vous pouvez ainsi ouvrir un même fichier dans autant d'onglets que vous le souhaitez.
{{Note|Gardez toujours à l'esprit qu'il n'y a qu'un seul fichier (module ou tampon de fichier en termes internes) affiché dans plusieurs vues. Ainsi, toute modification effectuée dans l'une de ces vues sera répercutée dans les autres vues (il ne s'agit pas de copier ou de dupliquer une modification). <br />
Autrement dit, toute modification de fichier depuis une fenêtre d'édition concerne le fichier lui-même et pas la fenêtre. Cette modification sera répercutée dans les autres vues. }}

===Conseils et astuces===

*'''Enregistrez''' la configuration des éditeurs en tant que disposition du bureau. Sinon, vous risquez de passer beaucoup de temps à définir une présentation qui ne sera pas sauvegardée.

{{Notes|

*Lorsque la disposition de bureau est modifiée, la configuration change également (par ex. lorsque l'EDI commence le débogage et passe en '''Disposition de débogage'''.
*Lorsque vous changez de disposition, tout groupe d'onglets qui ne trouve pas sa place dans la disposition est détaché et devient une fenêtre flottante.}}
*Activez '''Options''' > '''Enregistrement et récupération''' > '''Enregistrer le bureau du projet lors de la fermeture''' et '''Enregistrer l'état de l'éditeur à la fermeture d'un onglet'''.
*Lorsque vous enregistrez l'état de l'éditeur, vous enregistrez également la position de défilement, les zones réduites ou développées, etc. C'est très pratique lorsque plusieurs fenêtres d'édition du même fichier sont ouvertes. Ainsi, lorsque vous rouvrez votre bureau et rouvrez le projet (ou tout simplement, lorsque vous rouvrez un éditeur précédemment fermé), la nouvelle fenêtre d'édition s'affiche telle qu'elle était au moment de la fermeture.
*Pensez à désancrer les volets ancrables d'ancienne génération. Ils sont réduits sous forme de petit onglet sur un côté de la fenêtre principale. Vous pouvez les rendre visibles à nouveau en cliquant dessus, et ils restent affichés tant qu’ils ont la focalisation. Pour cela, vous devez cliquer sur le bouton d'épinglage dans la barre de titre du volet, à côté du bouton X. Cette fonctionnalité existe depuis de nombreuses années, mais elle n’était vraiment utile que lorsque l’espace à l'écran était limité. Maintenant que plusieurs fenêtres d'édition peuvent être fractionnées et ancrées ensemble, il devient très pratique de pouvoir désépingler les volets latéraux pour libérer de l’espace horizontal.
*Pensez à faire un clic droit sur un onglet '''> Fractionner > A droite''' (ou '''A gauche'''). L'utilisation de plusieurs colonnes est certainement la configuration la plus courante pour les vues fractionnées. Plus vous utiliserez cette fonctionnalité, plus vous constaterez son utilité.

==Voir aussi==

*[[Présentation de l'EDI|Présentation de l'EDI]]
*[[Aperçu et page d'accueil|Aperçu et page d'accueil]]

Compilateur Delphi

Yukikoi — Fri, 09 Oct 2026 17:05:25 GMT

Yukikoi a importé Compilateur Delphi par téléversement de fichier (1 version) LOC-23451

Nouvelle page

Construction

Yukikoi — Fri, 09 Oct 2026 17:05:25 GMT

Yukikoi a importé Construction par téléversement de fichier (1 version) LOC-23451

Nouvelle page

Champs (Delphi)

Yukikoi — Fri, 09 Oct 2026 17:05:25 GMT

Yukikoi a importé Champs (Delphi) par téléversement de fichier (1 version) LOC-23451

Nouvelle page

Barre de défilement

Yukikoi — Fri, 09 Oct 2026 17:05:24 GMT

Yukikoi a importé Barre de défilement par téléversement de fichier (1 version) LOC-23451

Nouvelle page

Delphi RTTI et C++Builder

Yukikoi — Fri, 09 Oct 2026 17:05:24 GMT

Yukikoi a importé Delphi RTTI et C++Builder par téléversement de fichier (1 version) LOC-23451

Nouvelle page

{{Parent|Utilisation des informations RTTI - Index|Utilisation des informations RTTI}}

==Découverte du type à l'exécution (réflexion)==

===Désambiguïsation===

Les informations RTTI de {{Delphi}} sont différentes des informations RTTI standard de C++ :

*Les informations RTTI de {{Delphi}} vous permettent d'explorer les champs, les méthodes d'une classe, et ainsi de suite.
*Les informations RTTI de C++ vous permettent d'identifier le type d'une variable et de comparer l'égalité des types, ou l'ordre de tri.

{{Note| L'option du compilateur {{Menu|Projet > Options > [[Compilateur C++|Compilateur C++]] > Activer la RTTI'''}} fait référence à une RTTI C++ standard.}}'''

===Génération des informations RTTI===

Seules les classes de style {{Delphi}} peuvent avoir des informations de style {{Delphi}} dans C++ (voir [[Declspec(delphiclass)|__declspec(delphiclass)]]).

Des informations RTTI peuvent être générées pour tout type de membre de classe (méthodes, champs, propriétés) avec toute visibilité (__published, public, protected, private). Pour contrôler la génération des informations RTTI, les spécifications suivantes peuvent être utilisées :

*[[Pragma explicit rtti|#pragma explicit_rtti]] (c'est l'équivalent C++ de [[Directive RTTI (Delphi)|<nowiki>{$RTTI}</nowiki>]])
*[[Declspec(delphirtti)|__declspec(delphirtti)]] (c'est l'équivalent C++ de [[Informations de type à l'exécution (Delphi)|<nowiki>{$M}/{$TYPEINFO}</nowiki>]])
*[[Published|__published]]

'''Exemple :'''<source lang="cpp">
#include <System.hpp>
#include <Rtti.hpp>
#include <tchar.h>
#include <stdio.h>

// Enable RTTI generation for private fields
#pragma explicit_rtti fields(private)

class __declspec(delphiclass) TBuffer {
private:
int wrHead, rdHead;

// ...
public:
TBuffer() {

}
};

// ---------------------------------------------------------------------------

int _tmain(int argc, _TCHAR* argv[]) {
TRttiContext context;

// Get class RTTI
TRttiInstanceType *cls = dynamic_cast<TRttiInstanceType*>
(context.GetType(__delphirtti(TBuffer)));

if (cls) {
// Get field RTTI
TRttiField *field = cls->GetField("wrHead");
if (field) {
printf("%ls", field->ToString().c_str());
}
else {
puts("\"wrHead\" doesn't have RTTI");
}
}
else {
puts("\"TBuffer\" doesn't have RTTI");
}

return 0;
}</source>

'''Sortie console :'''

wrHead: int @ 00

Dans cet exemple, les informations RTTI de classe sont extraites à l'aide de la fonction [[Delphirtti|__delphirtti]] (qui renvoie un pointeur sur une variable [[lib_fr:System.TypInfo.TTypeInfo|TTypeInfo]]). Il est possible de faire la même chose avec l'opérateur [[Classid|__classid]]. Voir le code suivant<source lang="cpp">
TRttiInstanceType *cls = dynamic_cast<TRttiInstanceType*>
(context.GetType(__classid(TBuffer)));</source>Sur la plate-forme Windows, le [[Delphirtti|__delphirtti]] d'un [[Wchar t|wchar_t]] renvoie un [[lib_fr:System.TypInfo.PTypeInfo|PTypeInfo]] qui correspond à la RTTI {{Delphi}} pour le {{Delphi}} [[lib_fr:System.WideChar|WideChar]].

Cette fonctionnalité est illustrée dans l'exemple de code suivant :

<source lang="cpp">
#include <stdio.h>

static System::UTF8String getTypeInfoName(System::Typinfo::PTypeInfo ti)
{
#ifndef _DELPHI_NEXTGEN
return System::UTF8String(ti->Name);
#else
int len = ti->Name;
const char* p = reinterpret_cast<char*>(&(ti->Name));
return System::UTF8String(p+1, len);
#endif
}

int main()
{
System::Typinfo::PTypeInfo pti;
pti = __delphirtti(char16_t);
printf("Kind=%d, Name='%s'\n", pti->Kind, getTypeInfoName(pti).c_str());
pti = __delphirtti(wchar_t);
printf("Kind=%d, Name='%s'\n", pti->Kind, getTypeInfoName(pti).c_str());
return 0;
}</source>

'''Sortie :'''

{| border="1" frame="hsides" rules="rows"
|-
!'''Plate-forme'''
!'''Sortie'''
|-
| style="text-align: left; vertical-align: top;" |
WIN64
| style="text-align: left; vertical-align: top;" |
Kind=1, Name='char16_t'<br />
Kind=9, Name='Char'
|}

===Enracinement du type===

Vous ne pouvez pas utiliser les méthodes [[lib_fr:System.Rtti.TRttiContext.FindType|FindType]] et [[lib_fr:System.Rtti.TRttiContext.GetTypes|GetTypes]] pour obtenir la RTTI {{Delphi}} pour les classes définies en langage C++ car [[lib_fr:System.Rtti.TRttiContext.FindType|FindType]] et [[lib_fr:System.Rtti.TRttiContext.GetTypes|GetTypes]] effectuent des recherches dans les packages d'exécution. Or, il n'existe pas d'enracinement de type dans les packages C++. Cela signifie que vous ne pourrez pas utiliser [[lib_fr:System.Rtti.TRttiPackage|TRttiPackage]] pour obtenir des informations sur un package dynamique construit avec C++Builder.

En revanche, le lieur {{Delphi}} enracine la RTTI dans les [[lib_fr:System.PackageInfoTable|tables d'informations des packages]]. En conséquence, en C++, vous pouvez charger et utiliser la RTTI de style {{Delphi}} depuis des modules {{Delphi}} (packages), comme dans le code suivant :

<source lang="cpp">
TRttiContext context;
TRttiType *rttiType = context.FindType("Classes.TStringList");
printf("%ls", rttiType->ToString()); // displays TStringList</source>

==Attributs==

Les attributs {{Delphi}} ne sont pas pris en charge dans {{CBuilder}}. {{CBuilder}} prend en charge les '''[[Fonctionnalités C++11 - Index|attributs de C++11]]''', qui sont différents des attributs {{Delphi}} :

*Les attributs {{Delphi}} représentent des informations supplémentaires pour le programmeur et ils peuvent être extraits à l'exécution.
*Les attributs C++11 représentent des informations supplémentaires pour le compilateur et ne sont pas spécifiques à RTTI.

==Voir aussi==

===Informations RTTI de {{Delphi}}===

*[[lib_fr:System.Rtti|API RTTI]]
*[[Utilisation des informations RTTI - Index|Utilisation des informations RTTI]]
*[[Présentation des attributs|Attributs et RTTI]]

===Informations RTTI de {{Delphi}} dans {{CBuilder}}===

*[[Declspec(delphirtti)|__declspec(delphirtti)]]

===Informations RTTI de C++===

*[[Identification de type à l'exécution (RTTI) - Index|Identification de type à l'exécution (RTTI) - Index]]
*[[Typeid|typeid]] (mot clé)
*[[Rtti et option -RT|__rtti et option -RT]]

[[Category:Référence C++]]
[[Category:C++]]
[[Category:RTTI]]

Accueil

Eric.revollo — Fri, 09 Oct 2026 15:13:25 GMT

← Version précédente		Version du 9 octobre 2026 à 15:13
Ligne 8 :		Ligne 8 :
	* [[Notes de release\|Notes de release]]		* [[Notes de release\|Notes de release]]
	* [[13 Florence - Release 1]]		* [[13 Florence - Release 1]]
			* [[13 Florence - Release 2]]
	* [[rad_en: Community Edition\|Community Edition]]		* [[rad_en: Community Edition\|Community Edition]]

Nouveautés

Eric.revollo — Fri, 09 Oct 2026 15:12:49 GMT

Eric.revollo a importé Nouveautés par téléversement de fichier (1 version)

Voir les modifications