Code Conversion Guide/fr: what changed

Revision 3 to 4. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Cette page traite de la façon de convertir le code existant en Delphi ou Kylix pour fonctionner avec le compilateur [[Free Pascal]] et l'IDE Lazarus. Bien que Lazarus et le compilateur Free Pascal ont des aspects en commun avec Delphi et Kylix, ce ne sont pas des clones. Il y a un certain nombre de différences de convention et d'appel de bibliothèque ... et dans quelques secteurs , FPC est amélioré et peut être plus exigeant sur une syntaxe correcte . Veuillez voir le guide [[Lazarus For Delphi Users]] pour une description de quelques unes des différences fonctionnelles .
2	2
3	3		Le but de ce guide est de documenter certaines des différences spécifiques qui sont fréquemment rencontrées pendant le processus de conversion de code en traduisant le code existant de Delphi à Lazarus.
4	4
5	5		Ce document a été placé dans la base de connaissance du wiki ainsi il pourrait être facilement complété par n'importe qui qui avait rencontré un problème unique et voudrait le signaler pour que d'autres s'en rendent compte.
6	6
7		-	~~## Contents~~
8		-
9		-	* 1 Choix d'un composant ou d'une bibliothèque pour la conversion
10		-	* 1.1 Où trouver le code pour convertir
11		-	* 1.2 Autorisation
12		-	* 1.3 Dépendances
13		-	* 1.4 Problèmes liés au Compilateur
14		-	* 1.5 Questions sur l'OS et de plate-forme
15		-	* 2 Faire la conversion
16		-	* 2.1 Paramétrer l'environnement de Lazarus pour un projet de conversion
17		-	* 2.1.1 Créer un projet test
18		-	* 2.1.2 Choses initiales à regarder
19		-	* 2.1.3 Sources Delphi VCL, Kylix CLX dans Lazarus
20		-	* 2.2 Problèmes de conversion et solutions
21		-	* 2.2.1 Fichier Delphi / Kylix équivalents dans Lazarus
22		-	* 2.2.2 Convertir les projets/fiches/unités Delphi vers Lazarus
23		-	* 2.2.3 Choix du bon mode du compilateur
24		-	* 2.2.4 Considérations sur les logiciels multiplate-formes
25		-	* 2.2.5 Les variables utiles pour le compilateur
26		-	* 2.2.6 32bit / 64 bit support
27		-	* 2.2.7 Trouver un identificateur manquant
28		-	* 2.2.8 Différences principales d'unité entre Lazarus et Delphi
29		-	* 2.2.9 Différences des Propriétés et methodes entre Delphi et FPC/LCL
30		-	* 2.2.10 Différence sémantique
31		-	* 2.2.10.1 Ordre d'évaluation des paramètres
32		-	* 2.2.10.2 Procédures/Fonctions imbriquées en variables procédurales
33		-	* 2.2.11 différence de syntaxe
34		-	* 2.2.11.1 Pour affecter un gestionnaire à un évènement vous devez le préfixer avec "@"
35		-	* 2.2.11.2 En appelant une variable procédure utilisez cette syntaxe : theprocname()
36		-	* 2.2.11.3 Déréférencement de pointeur d'enregistrement
37		-	* 2.2.11.4 Des parenthèses pour acceder aux chars d'une propriété string d'un objet
38		-	* 2.2.11.5 Ne confondez pas le pointeur et ce qui est pointé
39		-	* 2.2.12 Ressources
40		-	* 2.3 Une autre méthode pour convertir un projet Delphi ou Kylix vers Lazarus
41		-	* 3 Obtenir de l'aide
42		-	* 3.1 Documentation
43		-	* 3.2 Support par les pairs
44		-	* 3.3 Bases de connaissance
45		-	* 4 Empaqueter et livrer votre composant
46		-	* 4.1 Création d'un paquet Lazarus pour votre(vos) composant(s)
47		-	* 4.2 Documentation
48		-	* 4.3 Création d'une page de livraison du code
49		-	* 4.4 Soumission de votre comoposant
50		-
51	7		## Choix d'un composant ou d'une bibliothèque pour la conversion
52	8
53	9		### Où trouver le code pour convertir
54	10
55	11		Il y a beaucoup de code disponible sur le net qui peut être converti pour être utilisé par FPC et Lazarus . Voici une [[Page Of Code Sites/fr\|Page de sites avec du code]] qui est juste un début. S'il vous plaît, complétez-le si vous connaissez d'autres bonnes adresses. TurboPower Software a récemment réalisé son offre commerciale entièrement sous MPL (Licence publique de Mozilla). Une liste de paquets disponibles peut être trouvée [ici ](<http://sourceforge.net/users/tpsfadmin/>).
56	12
57	13		Pour éviter un double effort, les paquets qui ont été déjà été convertis sont listés sur la page [[Components and Code examples/fr\|composants et Exemples de code]]. Si vous avez converti un paquet ou travaillez sur un, veuillez ajouter une note sur la page [[Current conversion projects/fr\|Projets en cours de conversion]].
58	14
59	15		### Autorisation
60	16
61	17		Il existe des licences depuis le Freeware (domaine public) jusqu’à des versions plus restrictives interdisant toute modification, redistribution ou usage commercial. Avant d’entreprendre toute conversion, il est nécessaire d’examiner les droits attachés au code. Le type de la licence de protection est essentiel lorsque l’on colle sur une Form un composant imposant des droits incompatibles avec l’ensemble de l’application concernée.
62	18
63	19		Lors de la traduction de composants, respectez les souhaits de l’auteur et conservez les copyrights et les entêtes des licences avec les adresses E-mail et les url. De même, il souhaitable d'informer l'auteur que ses composants sont en cours de conversion ... Surtout si le composant est sous une License restrictive. Dans le cas de composants oubliés et plus exploités, les auteurs révisent souvent les droits associés.
64	20
65	21		Généralement le domaine public (Freeware) et le LGPL/MPL sont les plus souples pour la diffusion de composants. Pour obtenir plus d’information concernant la[Définition Open Source <http://www.opensource.org/docs/definition.php>] est un bon commencement. Vous trouverez aussi d’autres types de licences et leur impact sur le code y étant attaché.
66	22
67	23		### Dépendances
68	24
69	25		Une autre étape avant de commencer à travailler sur une conversion est vérifier que le code n'a pas des dépendances profondes avec d'autres paquets qui pourraient ne pas être disponibles ou qui représente un défi considérable de conversion. Quelques offres de freeware sont liées à ou bien prolongent les paquets propriétaires qui ne sont fréquemment plus disponibles ou viennent avec des licences inadéquates.
70	26
71	27		### Problèmes liés au Compilateur
72	28
73	29		Voir :
74	30
75	31		* [Problèmes connus](<http://www.freepascal.org/probs.var>)
76	32		* [Traqueur de bogues](<http://bugs.freepascal.org/my_view_page.php>)
77	33
78	34		### Questions sur l'OS et de plate-forme
79	35
80	36		Lazarus et le compilateur Free Pascal sont des outils de developpement multi plate-forme et multi-architecture. En revanche , la plupart du code existant Delphi a été spécifiquement conçu pour fonctionner sur un processeur Intel sous Win32 . Si votre composant candidat a beaucoup de code spécifique Win32 , il pourrait être sage d'essayer et de trouver une plateforme alternative . Mais ne laissez pas ceci vous stopper... c'est véritablement étonnant ce que la LCL supporte!
81	37
82	38		## Faire la conversion
83	39
84	40		### Paramétrer l'environnement de Lazarus pour un projet de conversion
85	41
86	42		#### Créer un projet test
87	43
88	44		* Placer le code à convertir dans un sous-répertoire (par exemple: convertdir)
89	45		* Lancer Lazarus
90	46		* Fichier->Tout Enregistrer vers le sous-répertoire convertdir. Les noms significatifs pour le Projet et l'unité par défaut sont optionnels.
91	47		* Ouvrir l'unité « principale » à convertir dans convertdir
92	48		* L'ajouter au projet : Projet->Ajouter le fichier de l'éditeur au Projet
93	49		* Lancer Outils->Vérification rapide de la syntaxe ou lancer Executer->Construire Tout pour commencer .
94	50
95	51		#### Choses initiales à regarder
96	52
97	53		* Les noms de fichier sont sensibles à la casse avec les versions de compileurs 1.0.x. Si vous travaillez avec cette version, faire que tout vos noms de fichiers soient en minuscules. Vous obtiendrez les erreurs "fichiers non trouvés" si vous ne le faites pas.
98	54
99	55		#### Sources Delphi VCL, Kylix CLX dans Lazarus
100	56
101	57		En convertissant des sources Delphi/Kylix, il est souvent utile de trouver des déclarations pour voir ce qu'une fonction spécifique fait. L'EDI Lazarus peut analyser les sources Delphi/Kylix. Pour faire ceci il a besoin de quelques chemins de recherche et paramètres du compilateur. Vous pouvez facilement paramétrer ceci dans Configuration->Editeur des directives des outils de code...->Inserer un modèle
102	58
103	59		### Problèmes de conversion et solutions
104	60
105	61		#### Fichier Delphi / Kylix équivalents dans Lazarus
106	62
107	63		Delphi / Kylix \| Description \| Lazarus \| Description
108	64		---\|---\|---\|---
109		-	.pas .dfm/.xfm, .dcu/.dpu, .dpr(Code source du projet), .res, .dof/.kof \--- \--- \--- \| Fichier source Delphi, Fiche Delphi, Unité compilée Delphi, Projet Delphi, Fichier de ressource Windows, Fichier d'options Delphi \| .pas, .pp .lfm, .o, .lpr \--- \--- .lrs, .lpi(Fichier de projet), .ppu \| Fichier unité Pascal, Fichier de donnée de fiche, Fichier d'unité compilée, Fichier de projet, Fichier de ressource, Fichier d'options du projet, Fichier de ressource de Lazarus, Fichier d'information de projet Lazarus, Fichier de description d'unité de FPC
	65	+	.pas .dfm/.xfm, · .dcu/.dpu, · .dpr(Code source du projet), · .res, · .dof/.kof · --- · --- · --- \| Fichier source Delphi, Fiche Delphi, · Unité compilée Delphi, · Projet Delphi, · Fichier de ressource Windows, · Fichier d'options Delphi \| .pas, .pp .lfm, · .o, · .lpr · --- · --- · .lrs, · .lpi(Fichier de projet), · .ppu \| Fichier unité Pascal, Fichier de donnée de fiche, · Fichier d'unité compilée, · Fichier de projet, · Fichier de ressource, · Fichier d'options du projet, · Fichier de ressource de Lazarus, · Fichier d'information de projet Lazarus, · Fichier de description d'unité de FPC
110	66
111	67		Ainsi, un fichier .dcu de Delphi corresponds grossièrement aux fichiers FPC .o et .ppu dans un seul fichier. Le .ppu est principalement la partie entête (interface), le .o principalement la partie implementation. Les principales exceptions sont les fonctions en-ligne qui dans la forme à insérer sont dans le .ppu.
112	68
113	69		#### Convertir les projets/fiches/unités Delphi vers Lazarus
114	70
115	71		Renommez ou copiez le fichier .dpr vers un fichier .lpr. Mettre en commentaire ou enlevez la directive {$R *.res} et ajouter une directive {$mode delphi}{$H+} ou {$mode objfpc}{$H+} au fichier .lpr. L'IDE Lazarus peut vous assister dans cette conversion à travers l'item du menu outils "Convertir un projet Delphi en projet Lazarus...". Il demande un fichier .dpr (projet Delphi) et le convertit en .lpr; en outre, il crée le fichier .lpi et convertit toutes les unités .
116	72
117	73		Beaucoup de fiches existantes de Delphi peuvent être converties pour fonctionner avec Lazarus en employant le convertisseur de fiche .dfm vers .lfm intégré de l'IDE. Il peut être trouvé sous le menu outils à l'item "Convertir un fichier DFM en LFM...". Faire appel à la boite de dialogue fichier, sélectionnez le(s) fichier(s) dfm et le convertisseur fera le reste .
118	74
119	75		Si vous devez convertir l'unité entière (avec ou sans une fiche), Lazarus inclut également un item intégré "Convertir une unité Delphi en unité Lazarus..." qui fera ce qui suit pour vous -
120	76
121	77		1. fixe le cas des noms de fichier include et des sections uses.
122	78		2. converti les fichiers .dfm vers les fichiers .lfm (actuellement sans contrôler le contenu, juste le format)
123	79		3. crée un fichier vide .lrs (le contenu sera créé plus tard )
124	80		4. Ajoute la directive {$mode delphi}
125	81		5. Remplace l'unité windows par LCLIntf
126	82		6. Ajoute l'unité LResources si nécessaire (c.-à-d. , si l'unité .lrs doit être utilisée; uses LResources peut être dans la partie implémentation )
127	83		7. Enlève l'unité de variantes
128	84		8. Enlève la directive {$R *.dfm}
129	85		9. Ajoute la section d'initialisation et la directive {$i unit.lrs}
130	86
131	87		Ceci permet la conversion rapide et facile de la plupart des unités du format Delphi au format Lazarus. Il ne fait aucun contrôle de validité, ou changements automatiques de syntaxe, aussi tout les changements de syntaxe que vous devez faire, les changements additionnels d'unité/de nom d'unité, ou les changements de fichier dfm/pas pour les contrôles/les différences de composants, doivent toujours être fait manuellement, bien que dans le temps quelques assistants(wizards) facilitant une partie de ceci, particulièrement la réparation des fiches converties(lfm), puissent devenir disponible .
132	88
133	89		#### Choix du bon mode du compilateur
134	90
135	91		Le compilateur [[Free Pascal/fr\|Free Pascal]] supporte 5 modes Pascal différents. Par exemple TP pour turbo pascal, vous laisse compiler des unités en turbo pascal. Il y a également un mode de compatibilité DELPHI qui peut être choisi pour rendre le code existant plus facile à convertir. Lazarus préfère le mode OBJFPC, qui est presque égal au mode DELPHI, mais est moins ambigu que la syntaxe de Delphi. Voici les points importants :
136	92
137	93		Le mode peut être choisi en ligne de commande ou au début de la source . Employer la ligne de commande a l'avantage , que vous n'avez pas besoin de changer la source, mais l'inconvénient , que les autres doivent être renseignés .
138	94
139	95		La plupart des unités Delphi peuvent être compilées par le compilateur [[Free Pascal/fr\|Free Pascal]] en ajoutant
140	96		```
141	97		{$IFDEF FPC}
142	98		{$MODE DELPHI}
143	99		{$ENDIF}
144	100		```
145	101
146	102		juste après le nom de l'unité .
147	103
148	104		Pour plus de détails à propos des modes de [[Free Pascal/fr\|Free Pascal]] voir la [Documentation de Free Pascal](<http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html>)
149	105
150	106		#### Considérations sur les logiciels multiplate-formes
151	107
152	108		* L'assembleur inline est toujours un problème parce qu'il liera le code à l'architecture Intel. Quelques développeurs font des prototypes d'algorithme en Pascal et utilisent la directive IFDEF avec leur assembleur optimisé. Heureusement TurboPower a fait ceci dans de nombreux endroits avec leur code . Si c'est le cas avec le paquet que vous convertissez , remettez la directive sur Pascal.
153	109		* Ne pas mettre en référence des endroits de mémoire spécifique comme le secteur de données du BIOS. Découvrez ce dont le code a besoin et essayez de trouver une alternative multiplate-forme .
154	110		* Ne pas faire les tours spécifiques du processeur (comme employer le compteur temporel d'Intel (time stamp counter)) sans insérer votre code dans une directive IFDEF pour la plate-forme que le code nécessite ... et fournissant une alternative pour des environnements qui n'ont pas les possibilités matérielles .
155	111		* Si vous avez besoin de quelque code spécifique au système d'exploitation(OS) , alors vous pouvez employer la directive IFDEF. Voir ci-dessous pour une liste des macros .
156	112
157	113		#### Les variables utiles pour le compilateur
158	114
159	115		Pour écrire du code, qui se comporte sur divers systèmes différemment, vous pouvez employer les directives {$IFDEF Name}.
160	116
161	117		* {$IfDef LCL}
162	118
163	119		Cette variable est définie en utilisant le paquet LCL. Utile pour écrire du code qui fonctionne avec la bibliothèque LCL et Delphi.
164	120
165	121		* {$IfDef LCLGtk}, {$IfDef LCLWin32}, {$IfDef LCLQt}, ...
166	122
167	123		Cette variable est définie en utilisant le paquet LCL et le jeux de composants spécifique est actuellement employé. Utile pour écrire du code qui fonctionne avec la bibliothèque LCL sur une plate-forme spécifique.
168	124
169	125		* {$IfDef FPC}
170	126
171	127		Cette variable est définie, en utilisant le compilateur FPC. Utile pour écrire du code, qui fonctionne avec FPC et Delphi.
172	128
173	129		* {$IfDef Unix}, {$IfDef Win32}, ...
174	130
175	131		Défini par FPC pour le système d'exploitation cible courant. Delphi définit "Linux", "Win32" et "MSWindows". [[Free Pascal/fr\|Free Pascal]] s'exécute sur beaucoup plus de plate-formes et ainsi on lui recommande d'employer l'item le plus courant. Par exemple "Unix" est défini pour Linux, FreeBSD, NetBSD et OpenBSD, là où Lazarus s'exécute déjà . Utilisez
176	132		```
177	133		{$IfDef Linux}
178	134		{$Define Unix}
179	135		{$EndIf}
180	136		```
181	137
182	138		pour contourner ceci pour Kylix .
183	139
184	140		Pour plus de détails voir la [Documentation de Free Pascal](<http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21>). Texte gras
185	141
186	142		#### 32bit / 64 bit support
187	143
188	144		Les pointeurs en 64bit demande 8 octets au lieu de 4 en 32bit. Le type 'Integer' demeure en 32bit pour compatibilité. Cela signifie que vous ne pouvez plus forcer les pointeurs en Integer et revenir en arrière. FPC définit deux nouveaux types : PtrInt and PtrUInt. PtrInt est une entier 32bit signé dans les plates-formes 32bit et un entier signé 64bit dans les plate-formes 64bit. La même chose avec PtrUInt mais en prenant des entiers non signés. Utilisez ce code qui devrait tourner pour Delphi et FPC :
189	145		```
190	146		{$IFNDEF FPC}
191	147		type
192	148		PtrInt = integer;
193	149		PtrUInt = cardinal;
194	150		{$ENDIF}
195	151		```
196	152
197	153		Remplacer tous les integer(SomePointerOrObject) par PtrInt(SomePointerOrObject).
198	154
199	155		Pour plus d'information, voir [[Multiplatform Programming Guide/fr\|Guide de programmation Multi plate-forme]].
200	156
201	157		#### Trouver un identificateur manquant
202	158
203	159		Il y a des différences dans la façon dont la bibliothèque LCL est organisée en comparaison avec la bibliothèque VCL de Delphi . Si vous obtenez une erreur "not found" du compilateur au sujet d'une classe ou d'un identificateur important, les chances sont bonnes qu'il/elle soit dans une unité différente. Une correspondance complète peut être trouvée en utilisant la commande grep avec le sous répertoire lazarus/docs/xml ou lcl.
204	160
205	161		Par exemple la classe tbutton utilisée généralement donne typiquement une erreur dans le code Delphi parce qu'il est placé dans une unité appelée buttons.pp. La commande suivante trouve l'unité correcte très rapidement (dans le répertoire source de Lazarus ):
206	162		```
207	163		grep -in ' tbutton =' lcl/*
208	164		```
209	165
210	166		#### Différences principales d'unité entre Lazarus et Delphi
211	167
212	168		Please add to this topic!
213	169
214	170		* Windows->Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
215	171
216	172		Comme la bibliothèque LCL n'est pas spécifiquement dédiée à Windows, le code qui est dans l'unité Windows de Delphi pour accéder directement à l'API Win32, est placé dans des interfaces distinctes, lequel se situe dans l'unité LCLIntf. Gardez à l'esprit que Lazarus n'émule pas win32. Beaucoup de fonctions sont absentes et certaines ne fonctionnent pas comme leur homologues win32. Ces fonctions existent seulement pour la compatibilité avec Delphi et devrait seulement être employées pour un portage rapide. La bibliothèque LCL modifie plusieurs des types, ainsi souvent LCLType, et parfois VCLGlobals sont exigés. LCLProc contient également quelques fonctions ce qui peut être utile pour la manipulation de plus bas niveau comme "FreeThenNil", comme c'est le cas dans Delphi 5 (et plus). Utilisez "DeleteAmpersands" pour enlever des esperluètes additionnelles d'une chaîne de caractères pour les contrôles (& contre && etc). L'unité d'interfaces doit être incluse dans le fichier .lpr pour initialiser les jeux de composants graphiques appropriés .
217	173
218	174		* Messages->LMessages
219	175
220	176		Les messages TControl des événements callback de Win32 au format WM_CALLBACK et leurs structures associées sont généralement situés dans DELPHI dans l’unité Messages. Dans la LCL ce type de messages et leurs structures se trouvent dans Lmessages, avec en général le changement de « WM » en « LM ». Par exemple WM_MOUSEENTER devient LM_MOUSEENTER et TWMMouse devient TLMMouse.
221	177
222	178		* Graphics, Controls->GraphTypes, GraphMath, Graphics, Controls
223	179
224	180		Afin de simplifier les référencements multiples et circulaires d’unités quelques nouveaux types ont été définis dans une unité appelée GraphType regroupant des éléments qui, dans Delphi, sont placés dans Graphics ou Controls (par exemple le BvNone des Panels). Vous aurez donc parfois à l’utiliser. De même, GraphMath est une autre unité, qui bien qu’incompatible avec Delphi inclut d’autres fonctionnalités utiles. Elle prend en compte la précision TFloatPoint, diverses routines de Béziers, les lignes, les arcs, la surcharge d’opérateur telle que Point1=Point2+Point3 et la comparaison de Trects : If (Rect1=Rect2) then …
225	181
226	182		* Mask->MaskEdit
227	183
228	184		Afin de la nommer plus intelligement l’unité des TMaskEdit est nommée [MaskEdit] au lieu du nébuleux Mask de beaucoup de versions de Delphi.
229	185
230	186		* StdCtrls->StdCtrls,Buttons
231	187
232	188		Dans beaucoup de versions de Delphi, Tbutton est situé dans StdCtrls, alors que TSpeedButton et TBitBtn sont dans Buttons. Plus simplement, la LCL place tous les types de boutons dans Buttons, ce qui peut occasionnellement interrompre la traduction du code. Il est donc préférable de l’inclure systématiquement.
233	189
234	190		#### Différences des Propriétés et methodes entre Delphi et FPC/LCL
235	191
236	192		* TBitmap inclu un Canvas dans la LCL
237	193		* [[Lazarus Faq\|Lazarus_Faq#Why are TForm.ClientWidth§ClientHeight the same as TForm.Width.2FHeight]]
238	194
239	195		#### Différence sémantique
240	196
241	197		##### Ordre d'évaluation des paramètres
242	198
243	199		Delphi garantit que tous les paramètres sont évalués de la gauche vers la droite (sauf si une convention d'appel est précisée et spéficie autre chose, pour s'interfacer avec des routines C p.ex). FPC ne présente pas cette garantie et peut evaluer les paramètres dans n’importe quel ordre afin de générer un code optimal.
244	200
245	201		##### Procédures/Fonctions imbriquées en variables procédurales
246	202
247	203		[voir l'article Wikipedia(en)](<https://en.wikipedia.org/wiki/Call_stack>)
248	204
249	205		Delphi passe le pointeur de cadre de la procédure parent toujours sur la pile, et c'est à l'appelant de l'enlever à nouveau. Cela signifie qu'aussi longtemps que vous n'accédez pas aux variables de la procédure parent, vous pouvez passer l'adresse de la fonction imbriquée à une autre fonction qui peut alors l'appeler comme n'importe quelle variable procédurale.
250	206
251	207		FPC de son côté, passe toujours le pointeur de cadre de la procédure parent comme un premier paramètre caché selon la convention d'appel employée, ce qui signifie que si vous appelez une procédure imbriquée comme une variable procédurale normale, tous les paramètres seront "décalés" d'une position.
252	208
253	209		En bref, n'appelez pas de procédure imbriquée au moyen d'une variable procédurale.
254	210
255	211		#### différence de syntaxe
256	212
257	213		SVP compléter cet article!
258	214
259	215		A cause de restrictions propres à FPC, des changements de synthaxe sont nécessaires. La directive {$Mode Delphi} autorise, comme Delphi, moins de rigueur. Aussi adaptez votre règles synthaxiques avec {$Mode ObjFPC} au plus vite, même si le code doit être partagé par Delphi et LCL. Certaines sont simplement de meilleurs pratiques et parfois parce que le mode Delphi n'est pas assez précis, ou dans quelques cas, un code acceptable pour Delphi ne fonctionne pas comme attendu avec FPC, même s'il pourrait compiler.
260	216
261	217		À cette fin, même si tous ces éléments ne sont pas strictement requis, la liste suivante de changements devrait être considérée comme obligatoire :
262	218
263	219		##### Pour affecter un gestionnaire à un évènement vous devez le préfixer avec "@"
264	220
265	221		Par exemple, pour assigner une procédure à un évènement "OnClick" d'un bouton :
266	222
267	223		Delphi \| FPC
268		-	~~---\|---~~
269		-	~~```~~
270		-	~~begin~~
271		-	~~if not Assigned(MyButton.OnClick) then~~
272		-	~~MyButton.OnClick:= SomeFunction;~~
273		-	~~//@ not required~~
274		-	~~//more code...~~
275		-	~~end;~~
276		-	~~```~~
277		-
278		-	\|
279		-	~~```~~
280		-	~~begin~~
281		-	~~if not Assigned(MyButton.OnClick) then~~
282		-	~~MyButton.OnClick:= @SomeFunction;~~
283		-	~~//@ IS required~~
284		-	~~//more code...~~
285		-	~~end;~~
286		-	~~```~~
	224	+	---\|---
	225	+	begin if not Assigned(MyButton.OnClick) then MyButton.OnClick:= SomeFunction; //@ not required //more code... end; \| begin if not Assigned(MyButton.OnClick) then MyButton.OnClick:= @SomeFunction; //@ IS required //more code... end;
287	226
288	227		NB : cela n'est pas limité aux seuls événements, mais concerne tous les types procéduraux.
289	228
290	229		##### En appelant une variable procédure utilisez cette syntaxe : theprocname()
291	230
292	231		En Delphi, il n'y a aucune différence entre un résultat de fonction et une variable. Par contre, il y en a une en FPC, ainsi pour appeler une fonction, même si elle n'a pas de paramètre, vous devez ajouter des parenthèses. Par exemple :
293	232
294	233		Delphi \| FPC
295		-	~~---\|---~~
296		-	~~```~~
297		-	~~With (SomeObject) do~~
298		-	~~begin~~
299		-	~~If Assigned(OnMyCallback) then~~
300		-	~~OnMyCallback;~~
301		-	~~//parenthesis not required~~
302		-	~~end;~~
303		-	~~```~~
304		-
305		-	\|
306		-	~~```~~
307		-	~~With (SomeObject) do~~
308		-	~~begin~~
309		-	~~If Assigned(OnMyCallback) then~~
310		-	~~OnMyCallback();~~
311		-	~~//parenthesis required~~
312		-	~~end;~~
313		-	~~```~~
	234	+	---\|---
	235	+	With (SomeObject) do begin If Assigned(OnMyCallback) then OnMyCallback; //parenthesis not required end; \| With (SomeObject) do begin If Assigned(OnMyCallback) then OnMyCallback(); //parenthesis required end;
314	236
315	237		##### Déréférencement de pointeur d'enregistrement
316	238
317	239		Dans Delphi , lorqu’on tente d’accéder aux membres d’un Record, il n’est pas nécessaire de faire la différence entre le pointeur du Record et le Record lui-même. FPC fait la distinction :
318	240
319	241		Delphi \| FPC
320		-	~~---\|---~~
321		-	~~```~~
322		-	~~Function GetSomeValue(ARecord: PMyRecord):Integer;~~
323		-	~~begin~~
324		-	~~If Assigned(ARecord) then~~
325		-	~~Result:=ARecord.SomeValue~~
326		-	~~else~~
327		-	~~Result:=0;~~
328		-	~~end;~~
329		-	~~```~~
330		-
331		-	\|
332		-	~~```~~
333		-	~~Function GetSomeValue(ARecord: PMyRecord):Integer;~~
334		-	~~begin~~
335		-	~~If Assigned(ARecord) then~~
336		-	~~Result:=ARecord^.SomeValue~~
337		-	~~else~~
338		-	~~Result:=0;~~
339		-	~~end;~~
340		-	~~```~~
	242	+	---\|---
	243	+	Function GetSomeValue(ARecord: PMyRecord):Integer; begin If Assigned(ARecord) then Result:=ARecord.SomeValue else Result:=0; end; \| Function GetSomeValue(ARecord: PMyRecord):Integer; begin If Assigned(ARecord) then Result:=ARecord^.SomeValue else Result:=0; end;
341	244
342	245		##### Des parenthèses pour acceder aux chars d'une propriété string d'un objet
343	246
344	247		Il est possible avec Delphi de traiter les propriétés comme des variables, même pour accéder directement aux valeurs particulières des Char d’un String. C’est impossible avec FPC, notamment lorsque des propriétés sont indexées (traitées comme des tableaux). Dans ce cas, la propriété appelée doit être comprise dans des parenthèses. Même si ce n’est pas toujours, le cas il est préférable de s’y astreindre systématiquement. Exemple :
345	248
346	249		Delphi \| FPC
347		-	~~---\|---~~
348		-	~~```~~
349		-	~~Type TSomeComponent=class(TComponent)~~
350		-	~~//More code...~~
351		-	~~Published~~
352		-	~~Property MyString:String index 3 read GetMyString;~~
353		-	~~//More code...~~
354		-	~~End;~~
355		-
356		-	~~var~~
357		-	~~MyChar:char;~~
358		-	~~begin~~
359		-	~~If Length(MyString)>2 then~~
360		-	~~//no parenthesis needed~~
361		-	~~MyChar:= MyString[3];~~
362		-	~~//More code...~~
363		-	~~end;~~
364		-	~~```~~
365		-
366		-	\|
367		-	~~```~~
368		-	~~Type TSomeComponent=class(TComponent)~~
369		-	~~//More code...~~
370		-	~~Published~~
371		-	~~Property MyString:String index 3 read GetMyString;~~
372		-	~~//More code...~~
373		-	~~End;~~
374		-
375		-	~~var~~
376		-	~~MyChar:char;~~
377		-	~~begin~~
378		-	~~If Length(MyString)>2 then~~
379		-	~~//parenthesis sometimes needed~~
380		-	~~MyChar:= (MyString)[3];~~
381		-	~~//More code...~~
382		-	~~end;~~
383		-	~~```~~
	250	+	---\|---
	251	+	Type TSomeComponent=class(TComponent) //More code... Published Property MyString:String index 3 read GetMyString; //More code... End; var MyChar:char; begin If Length(MyString)>2 then //no parenthesis needed MyChar:= MyString[3]; //More code... end; \| Type TSomeComponent=class(TComponent) //More code... Published Property MyString:String index 3 read GetMyString; //More code... End; var MyChar:char; begin If Length(MyString)>2 then //parenthesis sometimes needed MyChar:= (MyString)[3]; //More code... end;
384	252
385	253		##### Ne confondez pas le pointeur et ce qui est pointé
386	254
387	255		Parfois dans Delphi vous pouvez obtenir un pointeur, adressant un objet avec une valeur nulle. Bien que ce type de situation soit complexe, c’est très souvent le cas dans les grands paquets de composants afin de réduire les imbrications d’objets de différentes unités. Il est donc possible dans Delphi d’envoyer un pointeur nul à une fonction attendant un objet, sans se soucier du type d’objet associé au pointeur. En FPC vous ne devez pas confondre l’objet et son pointeur. La conversion de type est nécessaire.
388	256
389	257		Exemple :
390	258
391	259		Delphi \| FPC
392		-	~~---\|---~~
393		-	~~```~~
394		-	~~Unit 1~~
395		-	~~Type~~
396		-	~~TSomeObject=class(TComponent)~~
397		-	~~//More code...~~
398		-	~~End;~~
399		-
400		-	~~Procedure DoSomething(Value: TSomeObject);~~
401		-	~~Function GetSomeObject: TSomeObject;~~
402		-
403		-	~~Unit 2~~
404		-	~~Type~~
405		-	~~TSomeComponent=class(TComponent)~~
406		-	~~//More code...~~
407		-	~~Published SomeObject: Pointer;~~
408		-	~~//More code...~~
409		-	~~End;~~
410		-
411		-	~~Application~~
412		-	~~var~~
413		-	~~MyComponent: TSomeComponent;~~
414		-	~~begin~~
415		-	~~MyComponent.SomeObject:=GetSomeObject;~~
416		-	~~//More code...~~
417		-	~~DoSomething(MyComponent.SomeObject);~~
418		-	~~end;~~
419		-	~~```~~
420		-
421		-	\|
422		-	~~```~~
423		-	~~Unit 1~~
424		-	~~Type~~
425		-	~~TSomeObject=class(TComponent)~~
426		-	~~//More code...~~
427		-	~~End;~~
428		-
429		-	~~Procedure DoSomething(Value: TSomeObject);~~
430		-	~~Function GetSomeObject: TSomeObject;~~
431		-
432		-	~~Unit 2~~
433		-	~~Type TSomeComponent=class(TComponent)~~
434		-	~~//More code...~~
435		-	~~Published SomeObject: Pointer;~~
436		-	~~//More code...~~
437		-	~~End;~~
438		-
439		-	~~Application~~
440		-	~~var~~
441		-	~~MyComponent: TSomeComponent;~~
442		-	~~begin~~
443		-	~~MyComponent.SomeObject:=Pointer(GetSomeObject);~~
444		-	~~//More code...~~
445		-	~~DoSomething(TSomeObject(MyComponent.SomeObject));~~
446		-	~~end;~~
447		-	~~```~~
	260	+	---\|---
	261	+	Unit 1 Type TSomeObject=class(TComponent) //More code... End; Procedure DoSomething(Value: TSomeObject); Function GetSomeObject: TSomeObject; Unit 2 Type TSomeComponent=class(TComponent) //More code... Published SomeObject: Pointer; //More code... End; Application var MyComponent: TSomeComponent; begin MyComponent.SomeObject:=GetSomeObject; //More code... DoSomething(MyComponent.SomeObject); end; \| Unit 1 Type TSomeObject=class(TComponent) //More code... End; Procedure DoSomething(Value: TSomeObject); Function GetSomeObject: TSomeObject; Unit 2 Type TSomeComponent=class(TComponent) //More code... Published SomeObject: Pointer; //More code... End; Application var MyComponent: TSomeComponent; begin MyComponent.SomeObject:=Pointer(GetSomeObject); //More code... DoSomething(TSomeObject(MyComponent.SomeObject)); end;
448	262
449	263		#### Ressources
450	264
451	265		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Remarque: La section ci-dessous n'est peut-être pas nécessaire. Les dernières versions de Lazarus supportent directement les fichers .res. L'installateur Windows de Lazarus inclut un compilateur de ressource qui supporte les fichiers .rc. Sur Unix, assurez-vous que windres est installé ainsi vous pouvez utiliser les fichiers .rc. Se reporter à [[Lazarus Resources/fr\|Ressources FPC]].
452	266
453	267		Les fichiers de ressource de Delphi sont spécifiques à Win32 et ne sont pas compatible avec Lazarus, donc vous devez les recréer et les compiler avec l'outil Lazres. Lazres peut être trouvé dans le sous-dossier lazarus/tools. Si vous avez téléchargé les sources de Lazarus, vous aurez besoin de le compiler.
454	268
455	269		* cd lazarus/tools
456	270		* make install
457	271
458	272		Pour ajouter une ressource à votre application :
459	273
460	274		* lazres myresource.lrs mypix.xpm anotherpix.xpm
461	275		* Ajouter l'unité LResources à votre clause Uses
462	276		* Incluez le fichier .lrs que vous avez créé sous le bloc d'initialisation
463	277
464	278		Exemple:
465	279		```
466	280		function TForm1.LoadGlyph(const GlyphName: String): TBitMap;
467	281		begin
468	282		Result:= TPixmap.Create;
469	283		Result.LoadFromLazarusResource(GlyphName);
470	284		end;
471	285		//More code...
472	286		begin
473	287		Speedbutton1.glyph:= LoadGlyph('mypix');
474	288		//More code...
475	289		end;
476	290
477	291		initialization
478	292		{$I unit1.lrs}
479	293		{$I myresource.lrs}
480	294		end.
481	295		```
482	296
483	297		### Une autre méthode pour convertir un projet Delphi ou Kylix vers Lazarus
484	298
485	299		* Renommer ou copier tous les fichiers .dfm ou .xfm vers .lfm (les très anciennes versions de Delphi ne produisent pas de fichiers .dfm basés sur du texte. L'utilitaire convert est, si présent, dans le dossier \bin et doit être utilisé d'abord avec les .dfm)
486	300		* Renommer ou copier le fichier .dpr en .lpr.
487	301		* Apportez toutes les modifications nécessaires aux fichier .lpr.
488	302
489	303		1. Ajouter les directives {$mode delphi}{$H+} ou {$mode objfpc}{H+}
490	304		2. Ajouter 'Interfaces' à la clause Uses
491	305		3. Commenter ou supprimer {$R *.res} ou mettre en directive au besoin
492	306
493	307		* Apporter les modifications nécessaires à tous les fichiers d'unités :
494	308
495	309		1. Ajouter la directive {$mode delphi}{$H+} ou {$mode objfpc}{H+}
496	310		2. Ajouter 'LResources' - à faire : vérifier si c'est toujours à faire pour les les nouvelles versions de Lazarus
497	311		3. Si la fiche contient des boutons, ajouter l'unité 'Buttons' à la clause Uses.
498	312		4. Commenter ou supprimer les directives {$R .dfm} or {$R .xfm}
499	313		5. Ajouter la section 'Initialization' à la fin de chaque fichier d'unité, et ajouter la directive {$I unitname.lrs} dedans
500	314
501	315		* Sélectionner Projet->Nouveau projet depuis un fichier
502	316		* Sélectionner le fichier .lpr
503	317		* Dans la fenêtre 'Créer un nouveau projet', choisissez 'Application'
504	318		* Construisez le projet et faites les corrections nécessaire plus loin pour obtenir une compilation propre. A ce moment, le fichier .lpi est généré automatiquement. vous pouvez obtenir des messages 'Error reading Form', cliquer sur 'Continuer le chargement' dans ce cas.
505	319		* enregistrer tout, et vous avez un projet Lazarus :-)
506	320
507	321		## Obtenir de l'aide
508	322
509	323		Si vous rencontrez un problème pendant la conversion que vous ne pouvez pas résoudre, il y a une large variété d'endroits où l'on peut obtenir de l'aide.
510	324
511	325		### Documentation
512	326
513	327		---
514	328		Pour les problèmes purement Pascal Objet et FPC \| Le meilleur endroit pour commencer est la [Documentation de Free Pascal](<http://www.freepascal.org/docs-html/>) par Michaël Van Canneyt et Florian Klämpfl.
515	329		Pour les problème plus orientés vers Lazarus \| La documentation du projet dans la base de connaissance Lazarus-CCR [[Main Page/fr\|Page principale]] est le prochain endroit où vous regarderez.
516	330
517	331		### Support par les pairs
518	332
519		-	~~Pour poser des questions à des experts ou des développeurs plus avancés :~~
	333	+	Pour poser des questions à des experts ou des développeurs plus avancés :
520	334		Mailing lists \| You can post a question on any of the [mailing lists for the Free Pascal Compiler](<http://www.freepascal.org/maillist.html>) or the [FPC/Lazarus forums](<http://forum.lazarus.freepascal.org/index.php?action=forum>) where a lot of experts are subscribed.
521	335		Si vous avez accès à IRC: \| sur irc.freenode.net: [#fpc](<irc://irc.freenode.net/fpc>) pour FPC, ou [#lazarus-ide](<irc://irc.freenode.net/lazarus-ide>) pour Lazarus
522	336		Forum francophone d'entraide : \| sur [Developpez.com (Zone Pascal)](<http://www.developpez.net/forums/f21/autres-langages/pascal/>)
523	337
524	338		### Bases de connaissance
525	339
526	340		Il existe des bases de recherche et de connaissances exceptionnelles en ligne qui peuvent également être d'une grande aide pour apprendre de nouvelles techniques et résoudre des problèmes:
527	341
528	342		* Tamarack Associates exploite un [moteur de recherche](<http://codenewsfast.com/>) rapide particulièrement pour les archives Usenet de Borland.
529	343		* Mer Systems Inc. fournit un [moteur de recherche](<http://www.mers.com/searchsite.html>) similaire
530	344		* Une autre source d'information exceptionnelle ainsi qu'une capacité de [recherche](<http://www.efg2.com/Lab/search.htm>) sur site est Earl F. Glynn Computer Lab and Reference.
531	345
532	346		## Empaqueter et livrer votre composant
533	347
534	348		### Création d'un paquet Lazarus pour votre(vos) composant(s)
535	349
536	350		La création d'un paquet rend plus aisé le processus d'installation du code que vous avez converti... surtout si vous fournisseez plus d'un composant. Mattias Gärtner a écrit une vue d'ensemble des [[Lazarus Packages/fr\|paquets Lazarus]] qui devrait être lus préalablement à ce processus.
537	351
538	352		### Documentation
539	353
540	354		L'objectif de ce site et le format wiki vise à rendre facile et rapide la production d'une documentation de niveau professionnelle. Le wiki rend aussi possible de voir le résultat de votre travail immédiatement et de faire tous les changements que vous voulez en temps réel.
541	355
542		-	L'utilisation du wiki Lazarus-CCR pour créer une documentation de bel aspect est très simple. Si vous n'avez jamais utilisez de balisage auparavant, vous pouvez vous y familiariser à l'aide de l'aire d'entrainement [bac à sable](</index.php?title=Sand_Box/fr&action=edit&redlink=1> "Sand Box/fr $page does not exist$").
	356	+	L'utilisation du wiki Lazarus-CCR pour créer une documentation de bel aspect est très simple. Si vous n'avez jamais utilisez de balisage auparavant, vous pouvez vous y familiariser à l'aide de l'aire d'entrainement [[Sand Box/fr\|bac à sable]].
543	357
544	358		### Création d'une page de livraison du code
545	359
546	360		La livraison de la page de code contient l'information vitale sur votre composant qu'un téléchargeur aurait besoin de savoir, telle que la licence, les plates-formes prévues, le statut (alpha, bêta, stable...), d'où le télécharger, qui l'a écrit, est-ce qu'un support est disponible... etc.
547	361
548	362		La procédure suivante vous permettra de créer une page de publication de code avec votre navigateur :
549	363
550		-	* Aller vers le [Release new component](</index.php?title=Release_new_component/fr&action=edit&redlink=1> "Release new component/fr $page does not exist$")
	364	+	* Aller vers le [[Release new component/fr\|Release new component]]
551	365		* Taper le noms de votre composant dans la boîte de texte et cliquer sur _Create Article_
552	366		* Remplir le modèle et enregistrer.
553	367		* Editer la page [[Components and Code examples/fr\|Components and Code examples]] et ajouter le lien que vous venez de créer vers la section "Released Components". enregistrer la page modifiée.
554	368
555	369		### Soumission de votre comoposant
556	370
557		-	Si vous n'êtes pas le responsable de la livraison dans le projet, remonter votre composant vers le système de livraison de SourceForge et ajoutez-le à la liste des paquets de livraison. Autrement, envoyez-le à l'un des administrateur du projet ([Tom Lisjac](</User:Tom> "User:Tom") ou [Vincent Snijders](</User:Vincent> "User:Vincent")) et nous l'ajouterons au dépôt ("repository"). Avant que nous le déposions, vous devez créer une _Page de livraison de code_ pour décrire votre composant. Vous pouvez utiliser la page [Livraison d'un nouveau composant](</index.php?title=Release_new_component/fr&action=edit&redlink=1> "Release new component/fr $page does not exist$") pour commencer la création d'une telle page.
	371	+	Si vous n'êtes pas le responsable de la livraison dans le projet, remonter votre composant vers le système de livraison de SourceForge et ajoutez-le à la liste des paquets de livraison. Autrement, envoyez-le à l'un des administrateur du projet ([Tom Lisjac](</User:Tom> "User:Tom") ou [Vincent Snijders](</User:Vincent> "User:Vincent")) et nous l'ajouterons au dépôt ("repository"). Avant que nous le déposions, vous devez créer une _Page de livraison de code_ pour décrire votre composant. Vous pouvez utiliser la page [[Release new component/fr\|Livraison d'un nouveau composant]] pour commencer la création d'une telle page.
558	372
559		-	Si vous pensez que vous aurez encore besoin de développer votre composant, vous pouvez le déposer dans SVN, comme cela vous aurez encore accès à lui. Si nous nous lassons de soumettre vos correctifs, nous vous donnerons l'accès en écriture au SVN, afin que vous puissiez valider vos correctifs vous-même. Pour plus de détails, voir l'[Utilisation du référentiel SVN de Lazarus-ccr](</index.php?title=Using_the_Lazarus-ccr_SVN_repository/fr&action=edit&redlink=1> "Using the Lazarus-ccr SVN repository/fr $page does not exist$").
	373	+	Si vous pensez que vous aurez encore besoin de développer votre composant, vous pouvez le déposer dans SVN, comme cela vous aurez encore accès à lui. Si nous nous lassons de soumettre vos correctifs, nous vous donnerons l'accès en écriture au SVN, afin que vous puissiez valider vos correctifs vous-même. Pour plus de détails, voir l'[[Using the Lazarus-ccr SVN repository/fr\|Utilisation du référentiel SVN de Lazarus-ccr]].
560	374
561	375		---
562	376		From the Free Pascal wiki, page "Code Conversion Guide/fr", as the Internet Archive kept it on 2025-02-15, last changed on 2020-02-11. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history