Code Conversion Guide/pt: what changed

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

Old	New		Line
1	1		Guia de conversão do Delphi para o Lazarus
2	2
3	3		## Sobre
4	4
5	5		Esta página é sobre como converter um código para poder usá-lo no compilador [[Free Pascal]] e a IDE do Lazarus. O Lazarus e o Free Pascal tem aspectos em comum com o Delphi e Kylix, porém, não são clones. Há várias diferenças nos códigos e convenções... e em algumas áreas, o FPC pode exigir uma sintaxe mais correta. Por favor veja o guia [[Lazarus For Delphi Users]] para uma descrição de algumas das diferenças funcionais.
6	6
7	7		O propósito deste guia é documentar algumas das diferenças específicas que freqüentemente são encontradas durante o processo de conversão de código ao traduzir código existente de Delphi para Lazarus.
8	8
9	9		Este documento foi colocado na área de conhecimento-base de wiki para que assim pudesse ser ampliado facilmente por qualquer um que tenha encontrado um problema e gostaria de postar isto para outros estarem atentos
10	10
11	11		## Selecionando um componente ou biblioteca para conversão
12	12
13	13		### Onde achar conteúdo para converter
14	14
15	15		Há MUITOS códigos possíveis na internet de serem convertidos para serem usados com o FPC e o Lazarus. Aqui tem uma [[Page Of Code Sites]] por onde você pode começar. Por favor adicione outro link se encontrar algum outro local. TurboPower Software recentemente seus produtos comerciais sob a MPL. Uma lista de packages disponíveis pode ser encontrado [aqui](http://sourceforge.net/users/tpsfadmin/).
16	16
17	17		Para evitar retrabalho, packages que foram convertidas estão listadas em [[Components and Code examples]] Se você converteu uma package ou está convertendo, por favor adicione uma nota na página [[Current conversion projects]]
18	18
19	19		### Licenciamento
20	20
21	21		Licenças para a faixa de domínio de código existente freeware/domínio público para versões restritivas que proíbem a modificação, re-distribuição e uso comercial. Antes de converter qualquer pacote, é uma boa idéia analisar seu licenciamento e ter a certeza que ele vai ser compatível com o Lazarus e o compilador Free Pascal. Verificação de licença é especialmente importante com componentes, de vez que ao incorporar um a um formulário, isso pode impor a necessidade de obter uma licença, o que pode ser indesejável ou incompatível para o aplicativo inteiro.
22	22
23	23		Ao converter componentes, por favor, respeite os desejos do autor original e mantenha todos os direitos autorais e cabeçalhos de licenciamento junto com endereços de e-mail e url's. É cortês e, muitas vezes útil para informar o autor que a sua componente está sendo (ou foi) convertida... especialmente se o componente está sob uma licença restritiva. Novo interesse em um antigo ou esquecido componente, pode às vezes inspirar autores a revisar seus originais e excessivo licenciamento restritivo.
24	24
25	25		Em geral, Domínio Público (freeware), e o LGPL/MPL são as formas de licenciamento mais flexível para a distribuição de componentes. Para mais informações, o site [Open Source Definition](http://www.opensource.org/docs/definition.php) é um bom lugar para iniciar. Há também diversas comparações disponíveis para ajudar a esclarecer como os vários tipos de licenças de trabalho e qual o impacto que terá sobre o código que está sendo vinculado. Procure por "open source license comparison"
26	26
27	27		### Dependências
28	28
29	29		Outro passo antes de começar a trabalhar em uma conversão é verificar se o código não tem dependências profundas de outros pacotes que podem não estar disponíveis ou representam um desafio considerável de conversão. Algumas ofertas de freeware obrigam ou se estendem a pacotes proprietários que freqüentemente não estão disponíveis ou vêm com licenças inadequadas.
30	30
31	31		### Questões de Compilador
32	32
33	33		Atualmente a versão estável 1.0.x do compilador Free Pascal não suporta interfaces, threads ou registros Variant. Se o código que você está convertendo necessita desses construtores, você terá que usar o ramo de desenvolvimento 1.1 do compilador ... que não é sempre garantido para trabalhar com Lazarus.
34	34
35	35		Veja também:
36	36
37	37		- [Problemas conhecidos](http://www.freepascal.org/probs.html)
38	38		- [Unfixed bugs](http://www.freepascal.org/bugs/db.php3?statusfield=Unfixed)
39	39
40	40		### SO e problemas de plataforma
41	41
42	42		Lazarus e o compilador Free Pascal são cross-platform e ferramentas de desenvolvimento para serem usadas também em vários sistemas operacionais. Em contraste, a maioria dos códigos escritos em Delphi são especificamente escritos para rodar em um processador Intel sob Win32. Se o seu canditado a componente possui muito código específico da plataforma Win32, seria sábio procurar uma alternativa independente da plataforma. Mas não desista... é verdadeiramente incrível o suporte LCL.
43	43
44	44		## Fazendo a conversão
45	45
46	46		### Montando o ambiente de Lazarus para um projeto de conversão
47	47
48	48		#### Crie um projeto teste
49	49
50	50		- Coloque o código a ser convertido em um subdiretório (ex: c:\convertdir)
51	51		- Abra-o com o Lazarus
52	52		- File-\>Save All para o subdiretório c:\convertdir. Os nomes para o Projeto e a Unit Default são opcionais.
53	53		- Abra em c:\convertdir a unit "main" para ser convertida * Adicione-a ao projeto: Project-\>Add Active Unit to Project
54	54		- Clique em Tools-\>Quick Syntax Check ou em Run-\>Build All para começar.
55	55
56	56		#### Termos iniciais para se cuidar
57	57
58	58		- Nomes de arquivos são sensíveis ao letras maiúsculas e minúsculas nos compiladores da série 1.0.x Se você estiver trabalhando com uma versão como essa, faça com que todos os seus arquivos sejam escritos em minúsculas, pois do contrário, você terá como frase de erro "File not found" - arquivo não encontrado.
59	59
60	60		#### Fontes Delphi VCL, Kylix CLX no Lazarus
61	61
62	62		Ao converter fontes de Delphi/Kylix, é freqüentemente útil fazer uma declaração sobre o que uma função específica está fazendo. A IDE Lazarus pode analisar as fontes de Delphi/Kylix. Para isto, é necessário indicar o local dos arquivos para o compilador. Pode-se conseguir isso através do menu Environment-\>CodeTools Defines Editor-\>Insert Template
63	63
64	64		### Problemas de conversão e soluções
65	65
66	66		#### Arquivos Delphi / Kylix equivalentes no Lazarus
67	67
68	68		\| \| \| \|
69	69		\|----\|----\|----\|
70	70		\| Delphi / Kylix \| Lazarus \| Descrição \|
71	71		\| .pas .dfm / .xfm .dcu / .dpu .dpr .res .dof / .kof --- --- --- \| .pas, .pp .lfm .o .lpr --- --- .lrs .lpi .ppu \| Arquivo unit de Pascal Arquivos de dados do form Arquivo da unit compilada Arquivo do Projeto Arquivo de recursos Arquivo de opções do projeto Arquivo de recursos do Lazarus Arquivo de informações do projeto Arquivo de descrição de unit FPC \|
72	72
73	73		#### Contentendo projetos/forms/units Delphi para Lazarus
74	74
75	75		Renomeie ou copie o arquivo .dpr para um arquivo .lpr. Comente ou remova a diretiva
76	76
77	77		{\$R *.res}
78	78
79	79		e adicione
80	80
81	81		{\$mode delphi}{\$H+}
82	82
83	83		ou
84	84
85	85		{\$mode objfpc}{\$H+}
86	86
87	87		no arquivo .lpr. A IDE do Lazarus pode através do menu Tools no item "Convert Delphi Project to Lazarus Project". Ele solicita um arquivo .dpr (Delphi Project) e o converte para um .lpr; mais tarde, também cria um .lpi.
88	88
89	89		Existe várias maneiras de converter forms do Delphi através da IDE do Lazarus que realiza o trabalho da conversão do .dfm para o .lfm. Isso pode ser encontrado como item do menu Tools com o sob o nome "Convert DFM file to LFM". Clique nele, e na caixa de dialogo escolha seu arquivo .dmf e o conversor fará o resto.
90	90
91	91		Se você precisa converter a unit inteira (com ou sem um form), o Lazarus também inclui a opção de converter uma unit Delphi para uma Unit Lazarus, através do item "Convert Delphi unit to Lazarus unit" que fará o seguinte:
92	92
93	93		1. renomeiará os arquivos .pas and .dfm para minúsculas.
94	94		2. converterá .dfm para .lfm file (atualmente sem a verificação da validade do conteúdo; somente o formato)
95	95		3. criará um arquivo .lrs vazio (o conteúdo será adicionado mais tarde)
96	96		4. adicionará a diretiva
97	97		{\$mode delphi}
98	98		5. substituirá as unidades Windows por LCLIntf
99	99		6. adicionará units LResources se necessário (i.e., se o unit.lrs for usado;
100	100		o uso de LResources
101	101
102	102		pode ser implementado a parte)
103	103		7. removerá variáveis da unit
104	104		8. removerá a diretiva
105	105		{\$R *.dfm}
106	106		9. adicionará a seção de inicialização e a diretiva
107	107		{\$i unit.lrs}
108	108
109	109		Isto fará uma conversão rápida e fácil da maioria das Units Delphi ao formato do Lazarus. Isto não checa a validade, ou muda a sintaxe automática. Assim, qualquer mudança na sintaxe, mudanças adicionais nos nomes das Units, mudanças necessárias por causa de diferenças nos objetos/controles, você terá que fazer manualmente.
110	110
111	111		#### Selecting the right compiler mode
112	112
113	113		The [[Free Pascal]] Compiler supports 5 different pascal modes. For example TP for turbo pascal, lets you compile turbo pascal units. There is also a DELPHI compatibility mode that can be set to make existing code easier to convert. Lazarus prefers the OBJFPC mode, which almost equals the DELPHI mode, but is less ambigious than the Delphi syntax. Here are the important points:
114	114
115	115		The mode can be selected at command line or at the start of the source. Using the command line has the advantage, that you don't need to change the source, but the disadvantage, that others must be told.
116	116
117	117		Most Delphi units can be compiled by the [[Free Pascal]] compiler by adding
118	118
119		-	~~`{$IFDEF FPC}`\~~
120		-	~~` {$MODE DELPHI}`\~~
121		-	~~`{$ENDIF}`~~
	119	+	```
	120	+	{$IFDEF FPC}
	121	+	{$MODE DELPHI}
	122	+	{$ENDIF}
	123	+	```
122	124
123	125		right after the unit name.
124	126
125	127		For more details about [[Free Pascal]] modes see the [Free Pascal Documentation](http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html)
126	128
127	129		#### Cross-Platform considerations
128	130
129	131		- Inline assembler is always a problem because it will bind the code to the Intel architecture. Some developers do algorithm prototypes in Pascal and ifdef the their optimized assembler. Fortunately TurboPower did this in numerous places with their code. If this is the case with the package you're converting, throw the switch back to Pascal.
130	132		- Don't reference specific memory location like the BIOS data area. Find out what the code needs and try to find a cross platform alternative.
131	133		- Don't do processor specific tricks (like using the Intel TSC) without enclosing your code in an ifdef for the platform the code needs... and providing an alternative for environments that don't have the hardware capability.
132	134		- If you need some OS specific code, then you can use IFDEFs. See below for a list of macros.
133	135
134	136		#### Useful compiler variables
135	137
136	138		To write code, that behaves on different systems differently, you can use the
137	139
138	140		{\$IFDEF Name}
139	141
140	142		directives.
141	143
142	144		- {\$IfDef LCL}
143	145
144	146		This variable is defined, when using the LCL package. Useful to write code, that works with the LCL and Delphi.
145	147
146	148		- {\$IfDef FPC}
147	149
148	150		This variable is defined, when using the FPC compiler. Useful to write code, that works with FPC and Delphi.
149	151
150	152		- {\$IfDef Unix}
151	153
152	154		,
153	155
154	156		{\$IfDef Win32}
155	157
156	158		, ...
157	159
158	160		Defined by FPC for the current Target OS. Delphi defines "Linux", "Win32" and "MSWindows". [[Free Pascal]] runs on much more platforms and so it is recommended to use the more general items. For example "Unix" is defined for Linux, FreeBSD, NetBSD and OpenBSD, where Lazarus already runs. Use
159	161
160		-	~~`{$IfDef Linux}`\~~
161		-	~~` {$Define Unix}`\~~
162		-	~~`{$EndIf}`~~
	162	+	```
	163	+	{$IfDef Linux}
	164	+	{$Define Unix}
	165	+	{$EndIf}
	166	+	```
163	167
164	168		to work around this for Kylix.
165	169
166	170		For more details see the [Free Pascal Documentation](http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21).
167	171
168	172		#### Finding a missing identifier
169	173
170	174		There are differences in how the LCL is organized when compared to the Delphi VCL. If you get a "not found" compiler error about a major class or identifier, the chances are good that it's in a different unit. A complete cross reference can be found by grep'ing lazarus/docs/xml or the lcl subdirectory.
171	175
172	176		For example the commonly used tbutton typically throws an error in Delphi code because it's located in a unit named buttons.pp. The following command finds the correct unit very quickly (in the lazarus source directory):
173	177
174		-	~~` grep -in ' tbutton =' lcl/*`~~
	178	+	```
	179	+	grep -in ' tbutton =' lcl/*
	180	+	```
175	181
176	182		#### Major unit differences between Lazarus and Delphi
177	183
178	184		- - Please add to this topic! **
179	185
180	186		- Windows-\>Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
181	187
182	188		As the LCL is not windows specific, the code that is in the Delphi Windows unit for directly accessing the Win32 API is abstracted into seperate interfaces, which can be accessed from the LCLIntf unit. Keep in mind, that Lazarus does not emulate win32, so many functions are missing and some do not work as their win32 counterparts. These functions only exist for Delphi compatibility and should only be used for quick & dirty porting. LCL also breaks out many of the types, so often LCLType, and sometimes VCLGlobals are required. LCLProc also contains a few functions which can be useful for lower level handling such as "FreeThenNil" as is in Delphi 5 and higher, "DeleteAmpersands" to remove additional ampersands from a string for controls(& vs && etc). The Interfaces unit needs to be included in the .lpr file to initialize the appropriate widgetset.
183	189
184	190		- Messages-\>LMessages
185	191
186	192		TControl Messages for win32 event callbacks of the format WM_CALLBACK and the structs associated with them are often found in the Messages unit in Delphi. In the LCL these types of messages and there structs are usually found in LMessages, usually with name changes of WM to LM, so for instance WM_MOUSEENTER becomes LM_MOUSEENTER, and TWMMouse becomes TLMMouse.
187	193
188	194		- Graphics, Controls-\>GraphTypes, GraphMath, Graphics, Controls
189	195
190	196		To simplify some things and break complexity of circles between units, a few types have been abstracted into a shared unit called GraphType, which includes things, which in Delphi are located in Graphics or Controls, for instance the bvNone etc of panels. So sometimes you have to include it. Also a unit which, although incompatible with Delphi, adds other useful functionality is GraphMath, which adds a TFloatPoint for precision, misc routines for dealing with beziers, lines, and arcs, as well as some operator overloading for use with TPoints and TRect, such as for instance Point1 := Point2 + Point3, and comparing two rects like if (rect1 = rect2) then ...
191	197
192	198		- Mask-\>MaskEdit
193	199
194	200		For more intelligent naming considerations, the unit for TMaskEdit is called \[MaskEdit\\|\] instead of the slightly more nebulous Mask as in many versions of Delphi.
195	201
196	202		- StdCtrls-\>StdCtrls,Buttons
197	203
198	204		In many version of Delphi TButton is located in StdCtrls, while TSpeedButton and TBitBtn are in Buttons. For consistency and simplicity the LCL puts all button types in Buttons, which can occasionally break code conversion, so it is always a good idea to include.
199	205
200	206		#### Property and method differences Delphi -\> FPC/LCL
201	207
202	208		- TBitmap contains a canvas in the LCL
203	209
204	210		#### Syntax differences
205	211
206	212		Please add to this topic!
207	213
208	214		Because of the inherent strictness in FPC, some syntax changes are necessary, even though
209	215
210	216		{\$Mode Delphi}
211	217
212	218		does allow more laziness like Delphi does. For this reason complying as much with the syntax rules of
213	219
214	220		{\$Mode ObjFPC}
215	221
216	222		as possible is highly recommended, even when the codebase is still going to be shared between Delphi and the LCL. Some of these are simply better coding practices, and sometimes because Delphi mode is not entirely accurate, or in a few instances Delphi acceptible code does not function as expected with FPC, even though it might compile. To that end even though not all such are strictly required, the following list of changes should be considered mandatory :
217	223
218	224		When assigning an event handling entry point, prefix it with an "@"
219	225
220	226		For instance, you might assign a button callback manually
221	227
222	228		Delphi
223	229
224	230		FPC
225	231
226	232		begin
227	233
228	234		if not
229	235
230	236		Assigned(MyButton.OnClick)
231	237
232	238		then
233	239
234	240		` MyButton.OnClick:= SomeFunction; `
235	241
236	242		//@ not required
237	243
238	244		//more code...
239	245
240	246		end
241	247
242	248		;
243	249
244	250		begin
245	251
246	252		if not
247	253
248	254		Assigned(MyButton.OnClick)
249	255
250	256		then
251	257
252	258		` MyButton.OnClick:= @SomeFunction; `
253	259
254	260		//@ IS required
255	261
256	262		//more code...
257	263
258	264		end
259	265
260	266		;
261	267
262	268		When calling a procedure variable use this syntax
263	269		theprocname()
264	270
265	271		In Delphi there is no difference between a function result and a variable, however there is in FPC, so to call a function, even if it has no parameters, you must append parenthesis. For Example -
266	272
267	273		Delphi
268	274
269	275		FPC
270	276
271	277		With
272	278
273	279		(SomeObject)
274	280
275	281		do begin
276	282
277	283		If
278	284
279	285		Assigned(OnMyCallback)
280	286
281	287		then
282	288
283	289		` OnMyCallback; `
284	290
285	291		//parenthesis not required
286	292
287	293		end
288	294
289	295		;
290	296
291	297		With
292	298
293	299		(SomeObject)
294	300
295	301		do begin
296	302
297	303		If
298	304
299	305		Assigned(OnMyCallback)
300	306
301	307		then
302	308
303	309		` OnMyCallback(); `
304	310
305	311		//parenthesis required
306	312
307	313		end
308	314
309	315		;
310	316
311	317		When accessing values in a pointer to a record you must dereference first
312	318
313	319		In Delphi it is not required to de-reference a pointer to a record to access values within it, it can, in fact, be treated just like the record itself, or any other object. In FPC it must be first de-referenced. As an example,
314	320
315	321		Delphi
316	322
317	323		FPC
318	324
319	325		Function
320	326
321	327		GetSomeValue(ARecord: PMyRecord)
322	328
323	329
324	330		Integer;
325	331
326	332		begin
327	333
328	334		If
329	335
330	336		Assigned(ARecord)
331	337
332	338		then
333	339
334	340		` Result`
335	341
336	342
337	343		=
338	344
339	345		ARecord.SomeValue
340	346
341	347		else
342	348
343	349		` Result:= `
344	350
345	351		0
346	352
347	353		;
348	354
349	355		end
350	356
351	357		;
352	358
353	359		Function
354	360
355	361		GetSomeValue(ARecord: PMyRecord)
356	362
357	363
358	364		Integer;
359	365
360	366		begin
361	367
362	368		If
363	369
364	370		Assigned(ARecord)
365	371
366	372		then
367	373
368	374		` Result`
369	375
370	376
371	377		=
372	378
373	379		ARecord^.SomeValue
374	380
375	381		else
376	382
377	383		` Result:= `
378	384
379	385		0
380	386
381	387		;
382	388
383	389		end
384	390
385	391		;
386	392
387	393		When accessing chars of an indexed string Property of an object, it must be enclosed in parentheses
388	394
389	395		With Delphi it is possible to treat a Property exactly like some other const or var, even to accessing for instance individual chars of a string directly, while this is not always possible in FPC, specifically for indexed properties. Instead it must be enclosed in parentheses, to make distinct. While this may not always hold true it is probably a good practice to consider anyway. For example
390	396
391	397		Delphi
392	398
393	399		FPC
394	400
395	401		Type
396	402
397	403		TSomeComponent=
398	404
399	405		class
400	406
401	407		(TComponent)
402	408
403	409		//More code...
404	410
405	411		Published
406	412
407	413		Property
408	414
409	415		MyString:
410	416
411	417		String
412	418
413	419		index
414	420
415	421		3
416	422
417	423		read
418	424
419	425		GetMyString;
420	426
421	427		//More code...
422	428
423	429		End
424	430
425	431		;
426	432
427	433		var
428	434
429	435		` MyChar`
430	436
431	437
432	438		char;
433	439
434	440		begin
435	441
436	442		If
437	443
438	444		Length(MyString)\>
439	445
440	446		2
441	447
442	448		then
443	449
444	450		//no parenthesis needed
445	451
446	452		` MyChar:= MyString[`
447	453
448	454		3
449	455
450	456		\];
451	457
452	458		//More code...
453	459
454	460		end
455	461
456	462		;
457	463
458	464		Type
459	465
460	466		TSomeComponent=
461	467
462	468		class
463	469
464	470		(TComponent)
465	471
466	472		//More code...
467	473
468	474		Published
469	475
470	476		Property
471	477
472	478		MyString:
473	479
474	480		String
475	481
476	482		index
477	483
478	484		3
479	485
480	486		read
481	487
482	488		GetMyString;
483	489
484	490		//More code...
485	491
486	492		End
487	493
488	494		;
489	495
490	496		var
491	497
492	498		` MyChar`
493	499
494	500
495	501		char;
496	502
497	503		begin
498	504
499	505		If
500	506
501	507		Length(MyString)\>
502	508
503	509		2
504	510
505	511		then
506	512
507	513		//parenthesis sometimes needed
508	514
509	515		` MyChar:= (MyString)[`
510	516
511	517		3
512	518
513	519		\];
514	520
515	521		//More code...
516	522
517	523		end
518	524
519	525		;
520	526
521	527		You must typecast pointers to actual type when using with var or function of that type
522	528
523	529		Sometimes in Delphi you will have a null pointer variable representing an object. While it might seem a complex situation, it is oddly quite common especially in large component packs as a method of preventing too many circular includes between objects in different units. In Delphi it is then possible to send this null pointer to a function expecting that object, without bothering to typecast to actual type, in fpc you must typecast.
524	530
525	531		For example -
526	532
527	533		Delphi
528	534
529	535		FPC
530	536
531	537		Unit 1
532	538
533	539		Type
534	540
535	541		TSomeObject=
536	542
537	543		class
538	544
539	545		(TComponent)
540	546
541	547		//More code...
542	548
543	549		End
544	550
545	551		;
546	552
547	553		Procedure
548	554
549	555		DoSomething(Value: TSomeObject);
550	556
551	557		Function
552	558
553	559		GetSomeObject: TSomeObject;
554	560
555	561		Unit 2
556	562
557	563		Type
558	564
559	565		TSomeComponent=
560	566
561	567		class
562	568
563	569		(TComponent)
564	570
565	571		//More code...
566	572
567	573		Published
568	574
569	575		` SomeObject: Pointer`
570	576
571	577		;
572	578
573	579		//More code...
574	580
575	581		End
576	582
577	583		;
578	584
579	585		Application
580	586
581	587		var
582	588
583	589		` MyComponent: TSomeComponent`
584	590
585	591		;
586	592
587	593		begin
588	594
589	595		` MyComponent.SomeObject`
590	596
591	597
592	598		=
593	599
594	600		GetSomeObject;
595	601
596	602		//More code...
597	603
598	604		` DoSomething(MyComponent.SomeObject)`
599	605
600	606		;
601	607
602	608		end
603	609
604	610		;
605	611
606	612		Unit 1
607	613
608	614		Type
609	615
610	616		TSomeObject=
611	617
612	618		class
613	619
614	620		(TComponent)
615	621
616	622		//More code...
617	623
618	624		End
619	625
620	626		;
621	627
622	628		Procedure
623	629
624	630		DoSomething(Value: TSomeObject);
625	631
626	632		Function
627	633
628	634		GetSomeObject: TSomeObject;
629	635
630	636		Unit 2
631	637
632	638		Type
633	639
634	640		TSomeComponent=
635	641
636	642		class
637	643
638	644		(TComponent)
639	645
640	646		//More code...
641	647
642	648		Published
643	649
644	650		` SomeObject: Pointer`
645	651
646	652		;
647	653
648	654		//More code...
649	655
650	656		End
651	657
652	658		;
653	659
654	660		Application
655	661
656	662		var
657	663
658	664		` MyComponent: TSomeComponent`
659	665
660	666		;
661	667
662	668		begin
663	669
664	670		` MyComponent.SomeObject`
665	671
666	672
667	673		=
668	674
669	675		Pointer(GetSomeObject);
670	676
671	677		//More code...
672	678
673	679		` DoSomething(TSomeObject(MyComponent.SomeObject))`
674	680
675	681		;
676	682
677	683		end
678	684
679	685		;
680	686
681	687		#### Resources
682	688
683	689		Delphi resource files are win32 specific and not compatible with Lazarus, so you'll have to recreate and compile them using the lazres. Lazres can be found in the lazarus/tools subdirectory. If you've downloaded the Lazarus sources, you'll need to compile it first.
684	690
685	691		- cd lazarus/tools
686	692		- make install
687	693
688	694		To add a resource to your application:
689	695
690	696		- lazres myresource.lrs mypix.xpm anotherpix.xpm
691	697		- Add the LResources unit to your Uses clause
692	698		- Include the .lrs file you created under the initialization block
693	699
694	700		Example:
695	701
696	702		function
697	703
698	704		TForm1.LoadGlyph(
699	705
700	706		const
701	707
702	708		GlyphName:
703	709
704	710		String
705	711
706	712		): TBitMap;
707	713
708	714		begin
709	715
710	716		` Result:= TPixmap.Create`
711	717
712	718		;
713	719
714	720		` Result.LoadFromLazarusResource(GlyphName)`
715	721
716	722		;
717	723
718	724		end
719	725
720	726		;
721	727
722	728		//More code...
723	729
724	730		begin
725	731
726	732		` Speedbutton1.glyph:= LoadGlyph('mypix')`
727	733
728	734		;
729	735
730	736		//More code...
731	737
732	738		end
733	739
734	740		;
735	741
736	742		initialization
737	743
738	744		{\$I unit1.lrs}
739	745
740	746		{\$I myresource.lrs}
741	747
742	748		end
743	749
744	750		.
745	751
746	752		### Another method to convert a Delphi or Kylix project to Lazarus
747	753
748	754		- Rename or copy all .dfm or .xfm files to .lfm (Early Delphi versions do not produce a text-based .dfm file. The convert utility, if present in the \bin folder can be used to covert the .dfm first))
749	755		- Rename or copy .dpr file to .lpr
750	756		- Make necessary changes to .lpr file:
751	757
752	758		1. Add {\$mode delphi}{\$H+} or {\$mode objfpc}{H+} directives
753	759		2. Add 'Interfaces' to uses clause
754	760		3. Comment out or delete {\$R *.res} or directive
755	761
756	762		- Make necessary changes to all .pas unit files:
757	763
758	764		1. Add {\$mode delphi}{\$H+} or {\$mode objfpc}{H+} directives
759	765		2. Add 'LResources', and if the form has buttons, add 'Buttons' to uses clause
760	766		3. Comment out or delete {\$R .dfm} or {\$R .xfm} directive
761	767		4. Add 'Initialization' section at the end of each unit file, and add {\$I unitname.lrs} directive in it
762	768
763	769		- Select Project-\>New Project form file
764	770		- Select the .lpr file
765	771		- At 'Create a new project' window, choose 'Application'
766	772		- Build project and make further necessary corrections to get proper compilation, at this point the .lpi file is generated automaticaly. You may also get 'Error reading Form' messages, click on 'Continue Loading' if you do.
767	773		- Save all, and you have a Lazarus project :-)
768	774
769	775		## Getting Help
770	776
771	777		If you encounter a problem during conversion that you just can't solve, there are a wide variety of places to get help. For pure Object Pascal and FPC issues, the best place to start is the Free Pascal [Documentation](http://www.freepascal.org/docs-html/) by Michaël Van Canneyt and Florian Klämpfl. For more Lazarus oriented problems, the Lazarus Project Documentation in the Lazarus-CCR Knowledgebase \[Main Page\] is the next place to look. Finally 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 forums](http://community.freepascal.org:10000/bboard/) where a lot of experts are subscribed.
772	778
773	779		There are some outstanding search and knowledge bases online that can also be a great help for learning new techniques and solving problems. Tamarack Associates operates a fast [search](http://www.tamaracka.com/search.htm) engine specifically for the Borland usenet archives. Mer Systems Inc. provides a similar search [engine](http://www.mers.com/searchsite.html). Another outstanding source of information along with a sitewide [search](http://www.efg2.com/Lab/search.htm) capability is Earl F. Glynn's Computer Lab and Reference [Library](http://www.efg2.com/).
774	780
775	781		## Packaging and Releasing your component
776	782
777	783		### Creating a Lazarus package for your component(s)
778	784
779	785		Creating a package makes installing the code you've converted a much easier process... especially if you're providing more then one component. Mattias Gärtner has written an overview of [[Lazarus Packages]] that should be read before beginning this process.
780	786
781	787		### Documentation
782	788
783	789		The purpose of this site and the wiki format is to make the generation of professional documentation an easy and quick process. The wiki also makes it possible to see the results of your posting immediately and make any changes you'd like in real time.
784	790
785	791		Using the Lazarus-CCR wiki to create nice looking documentation is very easy. If you've never used wiki markup before, you can get familiar with it in the [[Sand Box]] practice area.
786	792
787	793		### Creating a Code Release Page
788	794
789	795		The Code Release Page contains vital information about your component that a potential downloader will need to know, such as license, intended platform, status (alpha, beta, stable...), where to download it, who wrote it, is support available... etc.
790	796
791	797		The following procedure will let you create a Code Release Page with your browser:
792	798
793	799		- Edit the [[Components and Code examples]] page and add a project name wiki link entry for your component in the "Released Components" section. Save the modified page.
794	800
795	801		- Go to the [[Component Release Template]], select all and copy. Hit the back button on your browser to return to the [[Components and Code examples]] page.
796	802		- Click on your new wiki component name entry and paste the release template into the blank edit box.
797	803		- Edit the template accordingly and hit save.
798	804		- Do edit-saves until your document looks the way you want it to.
799	805
800	806		### Submitting the component
801	807
802	808		If you're a release technician on the project, upload your component to the SourceForge File Release System and add it to the list of release packages. Otherwise send it to one of the project administrators (Tom Lisjac or Vincent Snijders) and we'll add it to the repository.
803	809
804	810		If you think you need to continue to develop on the component, we can also put it into CVS so you'll continue to have access to it.
805	811
806	812		## Contributors and Changes
807	813
808	814		This page has been converted from the epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide).
809	815
810	816		- Initial version by Tom Lisjac and Mattias Gärtner - 9/22/2003 VlxAdmin
811	817		- Moved Getting help from the main page. T. Lisjac - 9/24/2003 VlxAdmin
812	818		- Added documentation templates, procedure and links. 9/25/2003 VlxAdmin
813	819		- LCLLinux was renamed to LCLIntf, Jesus Reyes, 9/27/2003
814	820		- added more information on Unit changes, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
815	821		- Updated Syntax differences, including some examples, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
816	822		- FPC 1.0.x doesn't support interfaces, Vincent Snijders 9/28/2003
817	823		- Fixed some of the examples per new WikiWord definition, 9/28/2003 VlxAdmin
818	824		- Made code more consistant to remove last accidental Pascal WikiWord definitions, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
819	825		- Use tables for code examples for nice blocks, and easy side by side view of Delphi-\>FPC differences, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/17/2003
820	826		- Use pascal stylesheet to make example code more readable, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/18/2003
821	827		- Some translations and small corrections in translations exist -\> User: jrxds 12/01/2012
822	828
823	829		---
824	830		From the Free Pascal wiki, page "Code Conversion Guide/pt", as it stood on 2012-01-12 after a change by Jrxds, out of the wiki's dump of 2024-05-26. 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