Code Conversion Guide/pt: what changed

Revision 3 to 4. 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		-	~~```~~
	119	+	```text
120	120		{$IFDEF FPC}
121	121		{$MODE DELPHI}
122	122		{$ENDIF}
123	123		```
124	124
125	125		right after the unit name.
126	126
127	127		For more details about [[Free Pascal]] modes see the [Free Pascal Documentation](http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html)
128	128
129	129		#### Cross-Platform considerations
130	130
131	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.
132	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.
133	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.
134	134		- If you need some OS specific code, then you can use IFDEFs. See below for a list of macros.
135	135
136	136		#### Useful compiler variables
137	137
138	138		To write code, that behaves on different systems differently, you can use the
139	139
140	140		{\$IFDEF Name}
141	141
142	142		directives.
143	143
144	144		- {\$IfDef LCL}
145	145
146	146		This variable is defined, when using the LCL package. Useful to write code, that works with the LCL and Delphi.
147	147
148	148		- {\$IfDef FPC}
149	149
150	150		This variable is defined, when using the FPC compiler. Useful to write code, that works with FPC and Delphi.
151	151
152	152		- {\$IfDef Unix}
153	153
154	154		,
155	155
156	156		{\$IfDef Win32}
157	157
158	158		, ...
159	159
160	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
161	161
162		-	~~```~~
	162	+	```text
163	163		{$IfDef Linux}
164	164		{$Define Unix}
165	165		{$EndIf}
166	166		```
167	167
168	168		to work around this for Kylix.
169	169
170	170		For more details see the [Free Pascal Documentation](http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21).
171	171
172	172		#### Finding a missing identifier
173	173
174	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.
175	175
176	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):
177	177
178		-	~~```~~
	178	+	```text
179	179		grep -in ' tbutton =' lcl/*
180	180		```
181	181
182	182		#### Major unit differences between Lazarus and Delphi
183	183
184	184		- - Please add to this topic! **
185	185
186	186		- Windows-\>Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
187	187
188	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.
189	189
190	190		- Messages-\>LMessages
191	191
192	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.
193	193
194	194		- Graphics, Controls-\>GraphTypes, GraphMath, Graphics, Controls
195	195
196	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 ...
197	197
198	198		- Mask-\>MaskEdit
199	199
200	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.
201	201
202	202		- StdCtrls-\>StdCtrls,Buttons
203	203
204	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.
205	205
206	206		#### Property and method differences Delphi -\> FPC/LCL
207	207
208	208		- TBitmap contains a canvas in the LCL
209	209
210	210		#### Syntax differences
211	211
212	212		Please add to this topic!
213	213
214	214		Because of the inherent strictness in FPC, some syntax changes are necessary, even though
215	215
216	216		{\$Mode Delphi}
217	217
218	218		does allow more laziness like Delphi does. For this reason complying as much with the syntax rules of
219	219
220	220		{\$Mode ObjFPC}
221	221
222	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 :
223	223
224	224		When assigning an event handling entry point, prefix it with an "@"
225	225
226	226		For instance, you might assign a button callback manually
227	227
228	228		Delphi
229	229
230	230		FPC
231	231
232	232		begin
233	233
234	234		if not
235	235
236	236		Assigned(MyButton.OnClick)
237	237
238	238		then
239	239
240	240		` MyButton.OnClick:= SomeFunction; `
241	241
242	242		//@ not required
243	243
244	244		//more code...
245	245
246	246		end
247	247
248	248		;
249	249
250	250		begin
251	251
252	252		if not
253	253
254	254		Assigned(MyButton.OnClick)
255	255
256	256		then
257	257
258	258		` MyButton.OnClick:= @SomeFunction; `
259	259
260	260		//@ IS required
261	261
262	262		//more code...
263	263
264	264		end
265	265
266	266		;
267	267
268	268		When calling a procedure variable use this syntax
269	269		theprocname()
270	270
271	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 -
272	272
273	273		Delphi
274	274
275	275		FPC
276	276
277	277		With
278	278
279	279		(SomeObject)
280	280
281	281		do begin
282	282
283	283		If
284	284
285	285		Assigned(OnMyCallback)
286	286
287	287		then
288	288
289	289		` OnMyCallback; `
290	290
291	291		//parenthesis not required
292	292
293	293		end
294	294
295	295		;
296	296
297	297		With
298	298
299	299		(SomeObject)
300	300
301	301		do begin
302	302
303	303		If
304	304
305	305		Assigned(OnMyCallback)
306	306
307	307		then
308	308
309	309		` OnMyCallback(); `
310	310
311	311		//parenthesis required
312	312
313	313		end
314	314
315	315		;
316	316
317	317		When accessing values in a pointer to a record you must dereference first
318	318
319	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,
320	320
321	321		Delphi
322	322
323	323		FPC
324	324
325	325		Function
326	326
327	327		GetSomeValue(ARecord: PMyRecord)
328	328
329	329
330	330		Integer;
331	331
332	332		begin
333	333
334	334		If
335	335
336	336		Assigned(ARecord)
337	337
338	338		then
339	339
340	340		` Result`
341	341
342	342
343	343		=
344	344
345	345		ARecord.SomeValue
346	346
347	347		else
348	348
349	349		` Result:= `
350	350
351	351		0
352	352
353	353		;
354	354
355	355		end
356	356
357	357		;
358	358
359	359		Function
360	360
361	361		GetSomeValue(ARecord: PMyRecord)
362	362
363	363
364	364		Integer;
365	365
366	366		begin
367	367
368	368		If
369	369
370	370		Assigned(ARecord)
371	371
372	372		then
373	373
374	374		` Result`
375	375
376	376
377	377		=
378	378
379	379		ARecord^.SomeValue
380	380
381	381		else
382	382
383	383		` Result:= `
384	384
385	385		0
386	386
387	387		;
388	388
389	389		end
390	390
391	391		;
392	392
393	393		When accessing chars of an indexed string Property of an object, it must be enclosed in parentheses
394	394
395	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
396	396
397	397		Delphi
398	398
399	399		FPC
400	400
401	401		Type
402	402
403	403		TSomeComponent=
404	404
405	405		class
406	406
407	407		(TComponent)
408	408
409	409		//More code...
410	410
411	411		Published
412	412
413	413		Property
414	414
415	415		MyString:
416	416
417	417		String
418	418
419	419		index
420	420
421	421		3
422	422
423	423		read
424	424
425	425		GetMyString;
426	426
427	427		//More code...
428	428
429	429		End
430	430
431	431		;
432	432
433	433		var
434	434
435	435		` MyChar`
436	436
437	437
438	438		char;
439	439
440	440		begin
441	441
442	442		If
443	443
444	444		Length(MyString)\>
445	445
446	446		2
447	447
448	448		then
449	449
450	450		//no parenthesis needed
451	451
452	452		` MyChar:= MyString[`
453	453
454	454		3
455	455
456	456		\];
457	457
458	458		//More code...
459	459
460	460		end
461	461
462	462		;
463	463
464	464		Type
465	465
466	466		TSomeComponent=
467	467
468	468		class
469	469
470	470		(TComponent)
471	471
472	472		//More code...
473	473
474	474		Published
475	475
476	476		Property
477	477
478	478		MyString:
479	479
480	480		String
481	481
482	482		index
483	483
484	484		3
485	485
486	486		read
487	487
488	488		GetMyString;
489	489
490	490		//More code...
491	491
492	492		End
493	493
494	494		;
495	495
496	496		var
497	497
498	498		` MyChar`
499	499
500	500
501	501		char;
502	502
503	503		begin
504	504
505	505		If
506	506
507	507		Length(MyString)\>
508	508
509	509		2
510	510
511	511		then
512	512
513	513		//parenthesis sometimes needed
514	514
515	515		` MyChar:= (MyString)[`
516	516
517	517		3
518	518
519	519		\];
520	520
521	521		//More code...
522	522
523	523		end
524	524
525	525		;
526	526
527	527		You must typecast pointers to actual type when using with var or function of that type
528	528
529	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.
530	530
531	531		For example -
532	532
533	533		Delphi
534	534
535	535		FPC
536	536
537	537		Unit 1
538	538
539	539		Type
540	540
541	541		TSomeObject=
542	542
543	543		class
544	544
545	545		(TComponent)
546	546
547	547		//More code...
548	548
549	549		End
550	550
551	551		;
552	552
553	553		Procedure
554	554
555	555		DoSomething(Value: TSomeObject);
556	556
557	557		Function
558	558
559	559		GetSomeObject: TSomeObject;
560	560
561	561		Unit 2
562	562
563	563		Type
564	564
565	565		TSomeComponent=
566	566
567	567		class
568	568
569	569		(TComponent)
570	570
571	571		//More code...
572	572
573	573		Published
574	574
575	575		` SomeObject: Pointer`
576	576
577	577		;
578	578
579	579		//More code...
580	580
581	581		End
582	582
583	583		;
584	584
585	585		Application
586	586
587	587		var
588	588
589	589		` MyComponent: TSomeComponent`
590	590
591	591		;
592	592
593	593		begin
594	594
595	595		` MyComponent.SomeObject`
596	596
597	597
598	598		=
599	599
600	600		GetSomeObject;
601	601
602	602		//More code...
603	603
604	604		` DoSomething(MyComponent.SomeObject)`
605	605
606	606		;
607	607
608	608		end
609	609
610	610		;
611	611
612	612		Unit 1
613	613
614	614		Type
615	615
616	616		TSomeObject=
617	617
618	618		class
619	619
620	620		(TComponent)
621	621
622	622		//More code...
623	623
624	624		End
625	625
626	626		;
627	627
628	628		Procedure
629	629
630	630		DoSomething(Value: TSomeObject);
631	631
632	632		Function
633	633
634	634		GetSomeObject: TSomeObject;
635	635
636	636		Unit 2
637	637
638	638		Type
639	639
640	640		TSomeComponent=
641	641
642	642		class
643	643
644	644		(TComponent)
645	645
646	646		//More code...
647	647
648	648		Published
649	649
650	650		` SomeObject: Pointer`
651	651
652	652		;
653	653
654	654		//More code...
655	655
656	656		End
657	657
658	658		;
659	659
660	660		Application
661	661
662	662		var
663	663
664	664		` MyComponent: TSomeComponent`
665	665
666	666		;
667	667
668	668		begin
669	669
670	670		` MyComponent.SomeObject`
671	671
672	672
673	673		=
674	674
675	675		Pointer(GetSomeObject);
676	676
677	677		//More code...
678	678
679	679		` DoSomething(TSomeObject(MyComponent.SomeObject))`
680	680
681	681		;
682	682
683	683		end
684	684
685	685		;
686	686
687	687		#### Resources
688	688
689	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.
690	690
691	691		- cd lazarus/tools
692	692		- make install
693	693
694	694		To add a resource to your application:
695	695
696	696		- lazres myresource.lrs mypix.xpm anotherpix.xpm
697	697		- Add the LResources unit to your Uses clause
698	698		- Include the .lrs file you created under the initialization block
699	699
700	700		Example:
701	701
702	702		function
703	703
704	704		TForm1.LoadGlyph(
705	705
706	706		const
707	707
708	708		GlyphName:
709	709
710	710		String
711	711
712	712		): TBitMap;
713	713
714	714		begin
715	715
716	716		` Result:= TPixmap.Create`
717	717
718	718		;
719	719
720	720		` Result.LoadFromLazarusResource(GlyphName)`
721	721
722	722		;
723	723
724	724		end
725	725
726	726		;
727	727
728	728		//More code...
729	729
730	730		begin
731	731
732	732		` Speedbutton1.glyph:= LoadGlyph('mypix')`
733	733
734	734		;
735	735
736	736		//More code...
737	737
738	738		end
739	739
740	740		;
741	741
742	742		initialization
743	743
744	744		{\$I unit1.lrs}
745	745
746	746		{\$I myresource.lrs}
747	747
748	748		end
749	749
750	750		.
751	751
752	752		### Another method to convert a Delphi or Kylix project to Lazarus
753	753
754	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))
755	755		- Rename or copy .dpr file to .lpr
756	756		- Make necessary changes to .lpr file:
757	757
758	758		1. Add {\$mode delphi}{\$H+} or {\$mode objfpc}{H+} directives
759	759		2. Add 'Interfaces' to uses clause
760	760		3. Comment out or delete {\$R *.res} or directive
761	761
762	762		- Make necessary changes to all .pas unit files:
763	763
764	764		1. Add {\$mode delphi}{\$H+} or {\$mode objfpc}{H+} directives
765	765		2. Add 'LResources', and if the form has buttons, add 'Buttons' to uses clause
766	766		3. Comment out or delete {\$R .dfm} or {\$R .xfm} directive
767	767		4. Add 'Initialization' section at the end of each unit file, and add {\$I unitname.lrs} directive in it
768	768
769	769		- Select Project-\>New Project form file
770	770		- Select the .lpr file
771	771		- At 'Create a new project' window, choose 'Application'
772	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.
773	773		- Save all, and you have a Lazarus project :-)
774	774
775	775		## Getting Help
776	776
777	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.
778	778
779	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/).
780	780
781	781		## Packaging and Releasing your component
782	782
783	783		### Creating a Lazarus package for your component(s)
784	784
785	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.
786	786
787	787		### Documentation
788	788
789	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.
790	790
791	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.
792	792
793	793		### Creating a Code Release Page
794	794
795	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.
796	796
797	797		The following procedure will let you create a Code Release Page with your browser:
798	798
799	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.
800	800
801	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.
802	802		- Click on your new wiki component name entry and paste the release template into the blank edit box.
803	803		- Edit the template accordingly and hit save.
804	804		- Do edit-saves until your document looks the way you want it to.
805	805
806	806		### Submitting the component
807	807
808	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.
809	809
810	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.
811	811
812	812		## Contributors and Changes
813	813
814	814		This page has been converted from the epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide).
815	815
816	816		- Initial version by Tom Lisjac and Mattias Gärtner - 9/22/2003 VlxAdmin
817	817		- Moved Getting help from the main page. T. Lisjac - 9/24/2003 VlxAdmin
818	818		- Added documentation templates, procedure and links. 9/25/2003 VlxAdmin
819	819		- LCLLinux was renamed to LCLIntf, Jesus Reyes, 9/27/2003
820	820		- added more information on Unit changes, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
821	821		- Updated Syntax differences, including some examples, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
822	822		- FPC 1.0.x doesn't support interfaces, Vincent Snijders 9/28/2003
823	823		- Fixed some of the examples per new WikiWord definition, 9/28/2003 VlxAdmin
824	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
825	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
826	826		- Use pascal stylesheet to make example code more readable, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/18/2003
827	827		- Some translations and small corrections in translations exist -\> User: jrxds 12/01/2012
828	828
829	829		---
830	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