Lazarus For Delphi Users/pt: what changed

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

Old	New		Line
1	1		## Delphi -\> Lazarus
2	2
3	3		Lazarus é uma ferramena de desevolvimento rápido de aplicações (RAD) como o Delphi. O que significa que ela contém uma biblioteca de componentes visuais e uma IDE. A biblioteca de componentes do Lazarus (LCL) é muito parecida com a do Delphi que é a VCL. Muitas unidades, classes e propriedades tem o mesmo nome e funcionalidade. Com isto converter entre eles é fácil. Mas Lazarus "não" é um 'clone do Delphi de código aberto'. Não espere 100% de compatibilidade.
4	4
5	5		### As grandes diferenças
6	6
7	7		Lazarus é um software completamente de código aberto, escrito independente de plataforma, que utiliza o compilador [[Free Pascal]] (FPC). O FPC funciona em mais de 15 plataformas. Dentre elas, podemos citar o Windows (32 bits), o Linux, o FreeBSD e o MacOSX, mas, nem todos os pacotes e bibliotecas estão portados.
8	8
9	9		ATENÇÃO!!! O Lazarus não está completo, como não está este texto. Nós sempre procuramos novos desenvolvedores, geradores de pacotes, portadores e escritores de documentação.
10	10
11	11		## Delphi IDE -\> Lazarus IDE
12	12
13	13		### Projetos
14	14
15	15		O arquivo principal de uma aplicação Delphi é o .dpr . Enquanto que para o Lazarus é o .lpi (Lazarus Project Information - informação do projeto do lazarus). Mas, um .dpr no Delphi contém o código fonte do programa principal, informações das unidades utilizadas e diretivas de compilação, enquanto que o arquivo .lpr no Lazarus contém o código fonte do programa principal e o restante fica na .lpi .
16	16
17	17		Por exemplo:
18	18
19	19		Delphi armazena os caminhos das unidades no arquivo .dpr . Pela instância: unit1 in 'path/Unit1.pas'. Este 'in' especifica os caminhos das unidades para o Delphi e não está pronto para ser usado na Lazarus IDE. Não o use. Use preferivelmente os trajetos (caminhos) da unidade nas opções do compilador.
20	20
21	21		Uma importante regra: há sempre um projeto. Somente feche um projeto para sair do Lazarus ou abrir outro projeto. É porque um projeto Lazarus também é uma "sessão". Isto significa que o corrente editor indica também para armazenar no arquivo .lpi e são restaurados quando você reabre o projeto. Por exemplo, você está debugando um projeto, indica vários pontos de parada e marcadores. Você pode salvar o projeto a qualquer momento, fechar o Lazarus ou abrir outro projeto. Quando você reabrir o projeto, mesmo em outro computador, todos os seus pontos de parada, marcadores, arquivos abertos, posições do cursor, histórico de pulos, ... são restaurados.
22	22
23	23		### Editor de Código
24	24
25	25		Aproximadamente todas as teclas e atalhos podem ser definidos em environment-\>editor options-\>key mappings
26	26
27	27		A IDE (ambiente de desenvolvimento) do Lazarus tem várias ferramentas para fontes. Muitas delas são parecidas e trabalham de forma similar ao Delphi. Mas há uma importante diferença: Lazarus não usa o compilador para pegar informação do código. Ele interpreta os fontes diretamente. Isto tem muitas vantagens:
28	28
29	29		O editor de fonte trabalha com "comentários". Para Delphi os comentários no fonte são somente espaços entre o código. Nenhum comentário do código trabalha aqui e quando o código novo é automaticamente introduzido, seus comentários se perderão. Embora isto não seja completamente garantido, trabalha frequentemente. E quando o código novo é introduzido, o IDE usa algumas heuristicas para manter o comentário e codificá-lo junto. Por exemplo, isto não irá dividir a linha: "c:char; // comentário".
30	30
31	31		Delphi tem "Completar Código"(Ctrl+Space) é chamado "Identificar Completar" sobre o Lazarus. O Lazarus termo "Completar Código" tem uma característica, combinando "Completar Automaticamente Classe"(mesmo sobre Delphi), "Completar Variável Local" e "Completar Associação de Evento". Todos deles são invocados por Ctrl+Shift+C e a IDE determina pela posição do cursor, o que significa.
32	32
33	33		#### Exemplo para Completar Variável Local
34	34
35	35		Assuma que você tenha criado um novo método e escrito o seguinte "i:=3;"
36	36
37	37		procedure
38	38
39	39		TForm1.DoSomething;
40	40
41	41		begin
42	42
43	43		` i:= `
44	44
45	45		3
46	46
47	47		;
48	48
49	49		end
50	50
51	51		;
52	52
53	53		Posicionando o cursor sobre o identificador "i" e precionando Ctrl+Shift+C pegará:
54	54
55	55		procedure
56	56
57	57		TForm1.DoSomething;
58	58
59	59		var
60	60
61	61		i: Integer;
62	62
63	63		begin
64	64
65	65		` i:= `
66	66
67	67		3
68	68
69	69		;
70	70
71	71		end
72	72
73	73		;
74	74
75	75		#### Exemplo para Completar Associação de Evento
76	76
77	77		Um ótimo recurso do Object Inspector é automaticamente criar métodos. O mesmo você pode pegar no editor de fonte.\
78	78		Por Exemplo:
79	79
80	80
81	81		Button1.OnClick:=
82	82
83	83		Posicione o cursor atrás do operador de atribuição ":=" e precione Ctrl+Shift+C.
84	84
85	85		#### "Completar Palavras" Ctrl+W
86	86
87	87		Este trabalha igualmente ao "Identificar Completar", mas não trabalha em identificadores do Pascal, mas em todas as palavras. Deixa-o escolher de todas as palavras em todos os arquivos abertos que começam com as mesmas letras.
88	88
89	89		#### Suporte a Inclusão de Arquivos
90	90
91	91		Delphi não suporta isto, e você provavelmente não criará muitos arquivos incluídos ainda. Mas arquivos incluídos tem uma grande vantagem: Eles tornam possível escrever código (in)dependente de plataforma sem confundir com IFDEFs.
92	92
93	93		Por exemplo: método pulando, Completar Classe, encontrar declaração, ... todos trabalham com arquivos incluídos.
94	94
95	95		Há muitas opções para as características do código.
96	96
97	97		### Designer
98	98
99	99		\- Guidelines
100	100
101	101		#### Inspetor de Objetos
102	102
103	103		Nos ambientes de desenvolvimento do Delphi e do Lazarus temos o Inspetor de Objeto (Object Inspector) que é utilizado para editar e atribuir as propriedades, eventos, etc... do componente. Temos a seguir pequenas diferenças reparadas no uso:
104	104
105	105		1. Começando no Delphi 5 há uma árvore de objeto(Object TreeView) que pode ser usada para navegar e selecionar objetos de acordo com a hierarquia adicionando ao tradicional arrastar e soltar no Inspetor de Objeto. No Lazarus é parte do Inspetor de Objeto e é usada no lugar do padrão arrastar e soltar, você pode selecionar para usar ou não isto através do clique do botão direito do mouse no menu "Show Component Tree"
106	106		2. No Delphi duplo clique em um evento em branco irá auto criar um e abrir o Editor de Código(Source Editor) na posição, no Lazarus há um botão à direita do listar(...) selecionado que executa esta ação preferivelmente
107	107		3. No Delphi você deve manualmente apagar o nome de um evento no editor para remover a ligação, no Lazarus você pode listar os eventos(...) e selecionar "(None)".
108	108		4. Igualmente a Eventos, duplo clique em propriedades como booleana não irá mudar o valor, você deve selecionar o valor da lista. E para abrir aqueles com um editor de formulário associado, você deve clicar o botão '...' à direita do editor/lista
109	109
110	110		#### Pacotes
111	111
112	112		O Lazarus pode instalar e usar pacotes do Delphi ?
113	113
114	114		Não, porque eles requerem a magia do compilador Delphi.
115	115
116	116		Nós necessitamos que sejam feitos especialmente para Lazarus?
117	117
118	118		Sim. Crie um novo pacote, salve-o no diretório fonte do pacote (normalmente o mesmo diretório do .dpk(arquivo), adicion a LCL como pacote necessário e finalmente adicione os arquivos .pas . Você pode instalá-lo, ou usá-lo nos seus projetos agora. Há algumas diferenças entre pacotes do Lazarus e do Delphi, então por favor leia:
119	119
120	120		\- docs/Packages.txt nos fontes do lazarus.
121	121
122	122		### VCL -\> LCL
123	123
124	124		Mesmo que a VCL e a LCL sirvam ao mesmo propósito - de uma Hierarquia de Componentes de Orientação a Objeto para RAD - elas não são idênticas. Por exemplo, enquanto a VCL provê muitos componentes não visuais, a LCL provê somente componentes visuais, pois a maioria dos componentes não visuais (como aceso a bancos de dados) são providos pela FCL, incluída no [[Free Pascal]] .
125	125
126	126		Adicionalmente muitos controles da VCL podem não existir na LCL ou vice-versa, ou mesmo quando os controles existem em ambas, não são clones, e é necessário fazer modificações nas aplicações para portá-los.
127	127
128	128		O que segue é uma tentativa de descrever as maiores diferenças ou incompatibilidades entre as duas para usuários Delphi. Cobre primariamente as diferenças com a VCL do Delphi 4, às vezes do Delphi 5 e Delphi 6 ou Delphi 7 também, e com a LCL atual, como está no CVS. Pode não coincidir com a versão da VCL que você usa, ou com a LCL que você tem. Se você observar disparidades com a LCL do CVS atual ou com o seu Delphi, esteja à vontade para acrescentar ou modificar de modo que fique compreensível para todos.
129	129
130	130		#### TControl.Font/TControl.ParentFont
131	131
132	132		Na VCL é muito comum e normal usar nomes ou propriedades de fontes específicas, como negrito ou itálico para controles e esperar que estes valores sejam semmpre seguidos. Também se provê a propriedade TControl.ParentFont que certifica que o controle vai seguir a fonte do seu Parent. A suposição implícita sendo a de que esses valores vão ser sempre seguidos, independente da configuração da aparência das janelas.
133	133
134	134		Isto nem sempre é verdade na LCL, nem pode ser. Sendo a LCL cross-plataforma e cross-interface, naturalmente prefere fazer uma abordagem balanceada e vai procurar sempre usar Desktop/Aparência e Temas de Toolkit nativas de cada widget. Por exemplo, ao usar a interface GTK, o o GTK Theme supre uma fonte específica para botões, a LCL vai sempre procurar usar esta fonte.
135	135
136	136		Isto quer dizer que a maioria dos controles da LCL não têm o mesmo controle nível de desing que é freqüentemente esperado da VCL, a não ser somente para os controles que são desenhados no Canvas em vez de alocados na interface e que podem ser consistentemente modificados indepententemente da interface usada.
137	137
138	138		#### Control Dragging/Docking
139	139
140	140		Na VCL a maioria dos WinControls implementam métodos e funções de callback para manejar dragging e docking de controles, por exemplo para arrastar um controle de um painel e soltar em outro em tempo de execução.
141	141
142	142		Esta funcionalidade está atualmente não-implementada ou não-finalizada na LCL, em estágios iniciais de planejamento, e deve eventualmente dar suporte em algum nível de compatibilidade a este comportamento, se não da mesma maneira.
143	143
144	144		Isto atualmente significa que nenhum controle vai herdar ou usar as seguintes funções, procedimentos, propriedades ou eventos:
145	145
146	146		Protected
147	147
148	148		function
149	149
150	150		GetDockEdge(MousePos: TPoint): TAlign;
151	151
152	152		function
153	153
154	154		GetDragImages: TDragImageList;
155	155
156	156		function
157	157
158	158		GetFloating: Boolean;
159	159
160	160		function
161	161
162	162		GetFloatingDockSiteClass: TWinControlClass;
163	163
164	164		procedure
165	165
166	166		DoEndDrag(Target:TObject); X, Y: Integer);
167	167
168	168		procedure
169	169
170	170		DockTrackNoTarget(Source: TDragDockObject; X, Y: Integer);
171	171
172	172		procedure
173	173
174	174		DoEndDock(Target: TObject; X, Y: Integer);
175	175
176	176		procedure
177	177
178	178		DoDock(NewDockSite: TWinControl;
179	179
180	180		var
181	181
182	182		ARect: TRect);
183	183
184	184		procedure
185	185
186	186		DoStartDock(
187	187
188	188		var
189	189
190	190		DragObject: TDragObject);
191	191
192	192		procedure
193	193
194	194		DragCanceled;
195	195
196	196		procedure
197	197
198	198		DragOver(Source: TObject; X, Y: Integer; State: TDragState;
199	199
200	200		var
201	201
202	202		Accept: Boolean);
203	203
204	204		procedure
205	205
206	206		DoEndDrag(Target: TObject; X, Y: Integer);
207	207
208	208		procedure
209	209
210	210		DoStartDrag(
211	211
212	212		var
213	213
214	214		DragObject: TDragObject);
215	215
216	216		procedure
217	217
218	218		DrawDragDockImage(DragDockObject: TDragDockObject);
219	219
220	220		procedure
221	221
222	222		EraseDragDockImage(DragDockObject: TDragDockObject);
223	223
224	224		procedure
225	225
226	226		PositionDockRect(DragDockObject: TDragDockObject);
227	227
228	228		procedure
229	229
230	230		SetDragMode(Value: TDragMode);
231	231
232	232		property
233	233
234	234		DragKind: TDragKind;
235	235
236	236		property
237	237
238	238		DragCursor: TCursor;
239	239
240	240		property
241	241
242	242		DragMode: TDragMode;
243	243
244	244		property
245	245
246	246		OnDragDrop: TDragDropEvent;
247	247
248	248		property
249	249
250	250		OnDragOver: TDragOverEvent;
251	251
252	252		property
253	253
254	254		OnEndDock: TEndDragEvent;
255	255
256	256		property
257	257
258	258		OnEndDrag: TEndDragEvent;
259	259
260	260		property
261	261
262	262		OnStartDock: TStartDockEvent;
263	263
264	264		property
265	265
266	266		OnStartDrag: TStartDragEvent;
267	267
268	268		public
269	269
270	270		function
271	271
272	272		Dragging: Boolean;
273	273
274	274		function
275	275
276	276		ManualDock(NewDockSite: TWinControl; DropControl: TControl;
277	277
278	278		ControlSide: TAlign): Boolean;
279	279
280	280		function
281	281
282	282		ManualFloat(ScreenPos: TRect): Boolean;
283	283
284	284		function
285	285
286	286		ReplaceDockedControl(Control: TControl; NewDockSite: TWinControl;
287	287
288	288		DropControl: TControl; ControlSide: TAlign): Boolean;
289	289
290	290		procedure
291	291
292	292		BeginDrag(Immediate: Boolean; Threshold: Integer);
293	293
294	294		procedure
295	295
296	296		Dock(NewDockSite: TWinControl; ARect: TRect);
297	297
298	298		procedure
299	299
300	300		DragDrop(Source: TObject; X, Y: Integer);
301	301
302	302		procedure
303	303
304	304		EndDrag(Drop: Boolean);
305	305
306	306		property
307	307
308	308		DockOrientation: TDockOrientation;
309	309
310	310		property
311	311
312	312		Floating: Boolean;
313	313
314	314		property
315	315
316	316		FloatingDockSiteClass: TWinControlClass;
317	317
318	318		property
319	319
320	320		HostDockSite: TWinControl;
321	321
322	322		property
323	323
324	324		LRDockWidth: Integer;
325	325
326	326		property
327	327
328	328		TBDockHeight: Integer;
329	329
330	330		property
331	331
332	332		UndockHeight: Integer;
333	333
334	334		property
335	335
336	336		UndockWidth: Integer;
337	337
338	338		que as seguintes classes não existem ou não são utilizáveis:
339	339
340	340		TDragImageList =
341	341
342	342		class
343	343
344	344		(TCustomImageList)
345	345
346	346		`TDockZone = `
347	347
348	348		class
349	349
350	350		`TDockTree = `
351	351
352	352		class
353	353
354	354		(TInterfacedObject, IDockManager)
355	355
356	356		`TDragObject = `
357	357
358	358		class
359	359
360	360		(TObject)
361	361
362	362		`TBaseDragControlObject = `
363	363
364	364		class
365	365
366	366		(TDragObject)
367	367
368	368		`TDragControlObject = `
369	369
370	370		class
371	371
372	372		(TBaseDragControlObject)
373	373
374	374		`TDragDockObject = `
375	375
376	376		class
377	377
378	378		(TBaseDragControlObject)
379	379
380	380		e que as seguintes funções são inutilizáveis ou incompatíveis:
381	381
382	382		function
383	383
384	384		FindDragTarget(
385	385
386	386		const
387	387
388	388		Pos: TPoint;
389	389
390	390		AllowDisabled: Boolean) : TControl;
391	391
392	392		procedure
393	393
394	394		CancelDrag;
395	395
396	396		function
397	397
398	398		IsDragObject(sender: TObject): Boolean;
399	399
400	400		#### TEdit/TCustomEdit
401	401
402	402		Os controles Edit, ainda que funcionem essencialmente do mesmo modo na LCL como na VCL, não tem alguns itens que facilitariam a conversão
403	403
404	404		1. Devido a restrições em Interfaces, TEdit.PasswordChar não funciona em todas as interfaces ainda (mas deverá funcionar), em lugar de TCustomEdit.EchoMode emPassword deve ser usado em eventos em que o texto precisa ser escondido.
405	405		2. Os eventos OnDrag e OnDock não estão implementados ainda. Para mais informações veja a seção anterior Control Dragging/Docking.
406	406		3. Propriedades de fonte são ignorada por consitência com interface, para uma explanação detalhada veja TControl.Font/TControl.ParentFont
407	407
408	408		### (optional) TSplitter -\> TPairSplitter
409	409
410	410		Please Improve Me
411	411
412	412		Existe agora um controle TSplitter na LCL, não é mais necessário convertê-lo.
413	413
414	414		No entanto, se você o quiser, ele está explicado aqui:
415	415
416	416		O que segue é baseado em perguntas feitas por Vincent Snijders na mailing list, respondidas por [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson):
417	417
418	418		Na VCL, controles de splitting, que são um handle que pode ser arrastado entre dois componentes para dar mais ou menos espaço a um ou a outro, é realizado por um Splitter. Ele é visto por exemplo na IDE do Delphi entre o Code Explorer e o Source Viewer.
419	419
420	420		A LCL fornece o seu próprio controle chamado TPairSplitter, que serve ao mesmo propósito, mas não é compatível, de modo que "reparar" código quebrado da VCL ou de arquivos DFM do Delphi será necessário para portar código, ainda que haja muito em comum entre os dois controles.
421	421
422	422		Então o que são exatamente essas diferenças?
423	423
424	424		Well the biggest differences are a VCL TSplitter has no children, instead it is placed between two controls aligned properly, and allows resizing between them at runtime, regardless its own size. It must have two controls aligned on each size to do anything. A simple example would be form with a Left Aligned Panel, a left aligned Splitter, and a second client aligned panel. On run time you could then realign the size given each panel by dragging on the handle provided by this Splitter control.
425	425
426	426		On the LCL hand however, a TPairSplitter is a special kind of control, with two panels, and it can only be usefull if the controls to split are on these panels, but it will still perform a split between those panel whether or not anything is on them. So following the prior example, you would have a form with a TPairSplitter aligned client, and a panel aligned client on its left side, and a panel aligned client on its right side.
427	427
428	428		The other important difference is that in the VCl, since the TSplitter is its own TControl, then the position is kept relative to the other controls on resize, so for instance a client panel will grow while the other panels will not, thus the split position is relative to the alignment of the split controls,
429	429
430	430		In the LCL since the side panels are separate then the TPairSplitter has a Position property which is absolute relative to top or left. so on resize the actual position does not change according to contents, so a callback must be set to ensure the ratio is kept on resize if this is important.
431	431
432	432		For example if the Right side of a vertical split needs to have alClient like behaviour, you need to add a form resize callback which does something like :
433	433
434		-	~~`PairSplitter.Position := PairSplitter.Width - PairSplitter.Position; `~~
	434	+	``` pascal
	435	+	PairSplitter.Position := PairSplitter.Width - PairSplitter.Position;
	436	+	```
435	437
436	438		Então como posso converter um código existente usando TSplitter para TPairSplitter?
437	439
438	440		If the splitter and controls are created within an actual function(like form oncreate), conversion shouldn't be too difficult, primarily reorganize the code to create the controls in order of new hierarchy and set the parents of the child controls to split to the left/top and right/bottom portions of the PairSplitter. An example of the changes being -
439	441
440	442		VCL
441	443
442	444		LCL
443	445
444	446		var
445	447
446	448		` BottomPanel: TPanel`
447	449
448	450		;
449	451
450	452		` VerticalSplitter: TSplitter`
451	453
452	454		;
453	455
454	456		` LeftPanel: TPanel`
455	457
456	458		;
457	459
458	460		` HorizontalSplitter: TSplitter`
459	461
460	462		;
461	463
462	464		` MainPanel: TPanel`
463	465
464	466		;
465	467
466	468		begin
467	469
468	470		` BottomPanel:= TPanel.Create(Self)`
469	471
470	472		;
471	473
472	474		with
473	475
474	476		(BottomPanel)
475	477
476	478		do
477	479
478	480		begin
479	481
480	482		` Parent:= Self`
481	483
482	484		;
483	485
484	486		` Height:= `
485	487
486	488		75
487	489
488	490		;
489	491
490	492		` Align:= alBottom`
491	493
492	494		;
493	495
494	496		end
495	497
496	498		;
497	499
498	500		` VerticalSplitter:= TSplitter.Create(Self)`
499	501
500	502		;
501	503
502	504		with
503	505
504	506		(VerticalSplitter)
505	507
506	508		do
507	509
508	510		begin
509	511
510	512		` Parent:= Self`
511	513
512	514		;
513	515
514	516		` Align:= alBottom`
515	517
516	518		;
517	519
518	520		end
519	521
520	522		;
521	523
522	524		` HorizontalSplitter:= TSplitter.Create(Self)`
523	525
524	526		;
525	527
526	528		with
527	529
528	530		(HorizontalSplitter)
529	531
530	532		do
531	533
532	534		begin
533	535
534	536		` Parent:= Self`
535	537
536	538		;
537	539
538	540		` align:= alLeft`
539	541
540	542		;
541	543
542	544		end
543	545
544	546		;
545	547
546	548		` LeftPanel:= TPanel.Create(Self)`
547	549
548	550		;
549	551
550	552		with
551	553
552	554		(LeftPanel)
553	555
554	556		do
555	557
556	558		begin
557	559
558	560		` Parent:= Self`
559	561
560	562		;
561	563
562	564		` Width:= `
563	565
564	566		125
565	567
566	568		;
567	569
568	570		` Align:= alLeft`
569	571
570	572		;
571	573
572	574		end
573	575
574	576		;
575	577
576	578		` MainPanel:= TPanel.Create(Self)`
577	579
578	580		;
579	581
580	582		with
581	583
582	584		(MainPanel)
583	585
584	586		do
585	587
586	588		begin
587	589
588	590		` Parent:= Self`
589	591
590	592		;
591	593
592	594		` Align:= alClient`
593	595
594	596		;
595	597
596	598		` Caption:= `
597	599
598	600		'Hello'
599	601
600	602		;
601	603
602	604		end
603	605
604	606		;
605	607
606	608		end
607	609
608	610		;
609	611
610	612		var
611	613
612	614		` BottomPanel: TPanel`
613	615
614	616		;
615	617
616	618		` VerticalSplitter: TPairSplitter`
617	619
618	620		;
619	621
620	622		` LeftPanel: TPanel`
621	623
622	624		;
623	625
624	626		` HorizontalSplitter: TPairSplitter`
625	627
626	628		;
627	629
628	630		` MainPanel: TPanel`
629	631
630	632		;
631	633
632	634		begin
633	635
634	636		` VerticalSplitter:= TPairSplitter.Create(Self)`
635	637
636	638		;
637	639
638	640		with
639	641
640	642		(VerticalSplitter)
641	643
642	644		do
643	645
644	646		begin
645	647
646	648		` Parent:= Self`
647	649
648	650		;
649	651
650	652		` Align:= alClient`
651	653
652	654		;
653	655
654	656		` Width:= Self.Width`
655	657
656	658		;
657	659
658	660		` Height:= Self.Height`
659	661
660	662		;
661	663
662	664		` SplitterType:= pstVertical`
663	665
664	666		;
665	667
666	668		` Position:= Height - `
667	669
668	670		75
669	671
670	672		;
671	673
672	674		` Sides[`
673	675
674	676		0
675	677
676	678		\].Width:= Width
677	679
678	680		;
679	681
680	682		` Sides[`
681	683
682	684		0
683	685
684	686		\].Height:= Position
685	687
686	688		;
687	689
688	690		end
689	691
690	692		;
691	693
692	694		` HorizontalSplitter:= TPairSplitter.Create(Self)`
693	695
694	696		;
695	697
696	698		with
697	699
698	700		(HorizontalSplitter)
699	701
700	702		do
701	703
702	704		begin
703	705
704	706		` Parent:= VerticalSplitter.Sides[`
705	707
706	708		0
707	709
708	710		\]
709	711
710	712		;
711	713
712	714		` Width:= Self.Width`
713	715
714	716		;
715	717
716	718		` Height:= VerticalSplitter.Position`
717	719
718	720		;
719	721
720	722		` align:= alClient`
721	723
722	724		;
723	725
724	726		` SplitterType:= pstHorizontal`
725	727
726	728		;
727	729
728	730		` Position:= `
729	731
730	732		125
731	733
732	734		;
733	735
734	736		end
735	737
736	738		;
737	739
738	740		` LeftPanel:= TPanel.Create(Self)`
739	741
740	742		;
741	743
742	744		with
743	745
744	746		(LeftPanel)
745	747
746	748		do
747	749
748	750		begin
749	751
750	752		` Parent:= HorizontalSplitter.Sides[`
751	753
752	754		0
753	755
754	756		\]
755	757
756	758		;
757	759
758	760		` Align:= alClient`
759	761
760	762		;
761	763
762	764		end
763	765
764	766		;
765	767
766	768		` MainPanel:= TPanel.Create(Self)`
767	769
768	770		;
769	771
770	772		with
771	773
772	774		(MainPanel)
773	775
774	776		do
775	777
776	778		begin
777	779
778	780		` Parent:= HorizontalSplitter.Sides[`
779	781
780	782		1
781	783
782	784		\]
783	785
784	786		;
785	787
786	788		` Align:= alClient`
787	789
788	790		;
789	791
790	792		` Caption:= `
791	793
792	794		'Hello'
793	795
794	796		;
795	797
796	798		end
797	799
798	800		;
799	801
800	802		` BottomPanel:= TPanel.Create(Self)`
801	803
802	804		;
803	805
804	806		with
805	807
806	808		(BottomPanel)
807	809
808	810		do
809	811
810	812		begin
811	813
812	814		` Parent:= VerticalSplitter.Sides[`
813	815
814	816		1
815	817
816	818		\]
817	819
818	820		;
819	821
820	822		` Align:= alClient`
821	823
822	824		;
823	825
824	826		end
825	827
826	828		;
827	829
828	830		end
829	831
830	832		;
831	833
832	834		So as you can see, farely consistant with most control hierarchy. And if you are familiar with DFM's, the changes needed for DFM-\>LFM conversion should be farely obvious from the above, as they are the same sort of changes in Parent/Owner etc.
833	835
834	836		So the above example would be something like -
835	837
836	838		Delphi DFM
837	839
838	840		(extraneous values removed)
839	841
840	842		Lazarus LFM
841	843
842	844		(most width, height, etc. removed)
843	845
844	846		object
845	847
846	848		VerticalSplitter: TSplitter
847	849
848	850		` Height `
849	851
850	852		=
851	853
852	854		3
853	855
854	856		` Cursor `
855	857
856	858		=
857	859
858	860		crVSplit
859	861
860	862		` Align `
861	863
862	864		=
863	865
864	866		alBottom
865	867
866	868		end
867	869
868	870		object
869	871
870	872		HorizontalSplitter: TSplitter
871	873
872	874		` Width `
873	875
874	876		=
875	877
876	878		3
877	879
878	880		` Align `
879	881
880	882		=
881	883
882	884		alLeft
883	885
884	886		end
885	887
886	888		object
887	889
888	890		BottomPanel: TPanel
889	891
890	892		` Height `
891	893
892	894		=
893	895
894	896		75
895	897
896	898		` Align `
897	899
898	900		=
899	901
900	902		alBottom
901	903
902	904		end
903	905
904	906		object
905	907
906	908		LeftPanel: TPanel
907	909
908	910		` Width `
909	911
910	912		=
911	913
912	914		125
913	915
914	916		` Align `
915	917
916	918		=
917	919
918	920		alLeft
919	921
920	922		end
921	923
922	924		object
923	925
924	926		MainPanel: TPanel
925	927
926	928		` Align `
927	929
928	930		=
929	931
930	932		alClient
931	933
932	934		end
933	935
934	936		object
935	937
936	938		VerticalSplitter: TPairSplitter
937	939
938	940		` Align `
939	941
940	942		=
941	943
942	944		alClient
943	945
944	946		` SplitterType `
945	947
946	948		=
947	949
948	950		pstVertical
949	951
950	952		` Position `
951	953
952	954		=
953	955
954	956		225
955	957
956	958		` Height `
957	959
958	960		=
959	961
960	962		300
961	963
962	964		` Width `
963	965
964	966		=
965	967
966	968		400
967	969
968	970		object
969	971
970	972		Pairsplitterside1: TPairSplitterIde
971	973
972	974		object
973	975
974	976		HorizontalSplitter: TPairSplitter
975	977
976	978		` Align `
977	979
978	980		=
979	981
980	982		alClient
981	983
982	984		` Position `
983	985
984	986		=
985	987
986	988		125
987	989
988	990		object
989	991
990	992		Pairsplitterside3: TPairSplitterIde
991	993
992	994		` Width `
993	995
994	996		=
995	997
996	998		125
997	999
998	1000		object
999	1001
1000	1002		LeftPanel: TPanel
1001	1003
1002	1004		` Align `
1003	1005
1004	1006		=
1005	1007
1006	1008		alClient
1007	1009
1008	1010		` Width `
1009	1011
1010	1012		=
1011	1013
1012	1014		125
1013	1015
1014	1016		end
1015	1017
1016	1018		end
1017	1019
1018	1020		object
1019	1021
1020	1022		Pairsplitterside4: TPairSplitterIde
1021	1023
1022	1024		object
1023	1025
1024	1026		MainPanel: TPanel
1025	1027
1026	1028		` Align `
1027	1029
1028	1030		=
1029	1031
1030	1032		alClient
1031	1033
1032	1034		end
1033	1035
1034	1036		end
1035	1037
1036	1038		end
1037	1039
1038	1040		end
1039	1041
1040	1042		object
1041	1043
1042	1044		Pairsplitterside2: TPairSplitterIde
1043	1045
1044	1046		object
1045	1047
1046	1048		BottomPanel: TPanel
1047	1049
1048	1050		` Align `
1049	1051
1050	1052		=
1051	1053
1052	1054		alClient
1053	1055
1054	1056		` Height `
1055	1057
1056	1058		=
1057	1059
1058	1060		75
1059	1061
1060	1062		end
1061	1063
1062	1064		end
1063	1065
1064	1066		end
1065	1067
1066	1068		### TCustomTreeView/TTreeView
1067	1069
1068	1070		Ambas, VCL e LCL, fornecem um componente TCustomTreeView/TTreeView, usado para lista estruturada de árvore de dados com múltiplos nós e seleção avançada e, listas de imagens, e enquanto características reais são comparáveis, nem todas as propriedades são inteiramente compatíveis. As principais diferenças são as seguintes -
1069	1071
1070	1072		Incomplete list, also update to include TCustomTreeView Mark functions and protected methods
1071	1073
1072	1074		1. A LCL provê para o componente TCustomTreeView.Options, um conjunto de opções que podem ser ajustadas no controle para mudar seu comportamento e aparência. Estas opções são:
1073	1075		- tvoAllowMultiselect - enables multi node select mode, equivalent to enabling TCustomTreeView.MultiSelect in the D6 VCL
1074	1076		- tvoAutoExpand - Auto Expand nodes, equivalent to enabling TCustomTreeView.AutoExpand
1075	1077		- tvoAutoInsertMark - Update the Drag preview on mouse move.
1076	1078		- tvoAutoItemHeight - Adjust the item heights automatically.
1077	1079		- tvoHideSelection - Do not mark the selected item.
1078	1080		- tvoHotTrack - use Hot Tracking, equivalent to enabling TCustomTreeview.HotTrack
1079	1081		- tvoKeepCollapsedNodes - When shrinking/folding nodes, keep the child nodes
1080	1082		- tvoReadOnly - make Treeview read only, equivalent to enabling TCustomTreeview.ReadOnly
1081	1083		- tvoRightClickSelect - allow using Mouse Right Clicks to select nodes, equivalent to enabling TCustomTreeView.RightClickSelect
1082	1084		- tvoRowSelect - allow selecting rows, equivalent to enabling TCustomTreeView.RowSelect
1083	1085		- tvoShowButtons - show buttons, equivalent to enabling TCustomTreeView.ShowButtons
1084	1086		- tvoShowLines - show node lines, equivalent to enabling TCustomTreeView.ShowLines
1085	1087		- tvoShowRoot - show root note, equivalent to enabling TCustomTreeView.ShowRoot
1086	1088		- tvoShowSeparators - show seperators
1087	1089		- tvoToolTips - show tooltips for individual nodes
1088	1090		2. The LCL provides additional properties:
1089	1091		- TCustomTreeView.OnSelectionChange event
1090	1092		- TCustomTreeView.DefaultItems, for the default number of Items
1091	1093		- TCustomTreeView.ExpandSignType to determine sign used on expandable/collapsible nodes
1092	1094		3. While most On Drag/Dock Events are available in the LCL they do not work. For more information please see earlier section on Control Dragging/Docking.
1093	1095
1094	1096		### Messages / Events
1095	1097
1096	1098		The order and frequency of messages and events (OnShow, OnActivate, OnEnter, ...) differ from the VCL and depend on the widgetset. The LCL provides a subset of WinAPI like messages to make porting of Delphi components easier, but almost all LCL messages work a little bit different than the VCL/WinAPI counterpart. The biggest part of Delphi code using WinAPI messages uses them, because the VCL lacks a feature or for speed reasons. Such things will seldom work the same under the LCL, so they must be checked manually. That's why LCL messages are called for example LM_SIZE instead of WM_SIZE (unit lmessages).
1097	1099
1098	1100		## Original Contributors and changes
1099	1101
1100	1102		This page has been converted from the epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusForDelphiUsers).
1101	1103
1102	1104		- Initial import and formatting - VlxAdmin 9/26/2003
1103	1105		- Begin VCL -\> LCL with a section on TSplitter -\> TPairSplitter - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/30/2003
1104	1106		- Add TControl.Font/TControl.ParentFont to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/30/2003
1105	1107		- Update TEdit/TCustomEdit section in VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
1106	1108		- Add Control Dragging/Docking to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
1107	1109		- Added "Object Inspector" to Delphi IDE -\> Lazarus IDE - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
1108	1110		- Added initial "TCustomTreeView/TTreeView" to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
1109	1111		- Added introduction to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
1110	1112		- Fixed some typos - Vincent 10/2/2003
1111	1113		- Fixed Typo User:Kirkpatc 20 May 2004
1112	1114		- Portuguese translation and small corrections - User: jrxds 12/01/2012
1113	1115
1114	1116		## See Also
1115	1117
1116	1118		[[Code Conversion Guide\|Code Conversion Guide (from Delphi & Kylix)]]
1117	1119
1118	1120		[[Compile With Delphi]]
1119	1121
1120	1122		---
1121	1123		From the Free Pascal wiki, page "Lazarus For Delphi Users/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