Lazarus For Delphi Users/es: what changed

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

Old	New		Line
1	1		Este escrito está dirigido a usuarios interesados en Lazarus que conocen Delphi, ya que describe las diferencias entre ambos.
2	2
3	3		## Delphi -\> Lazarus
4	4
5	5		Lazarus es una herramienta de desarrollo rápido de aplicaciones, al igual que Delphi. Esto significa que dispone de una biblioteca de componentes visuales y de un entorno de desarrollo integrado (IDE). La librería de componentes de Lazarus (LCL) es muy similar a la VCL de Delphi. Muchas unidades, clases y propiedades tienen el mismo nombre e idéntica funcionalidad. Esto hace que el paso de uno o otro sea fácil. Pero Lazarus no es un clon Delphi de fuentes libres. No esperes por tanto una compatibilidad total.
6	6
7	7		### La mayor diferencia
8	8
9	9		Lazarus es completamente libre, está escrito para ser independiente de la plataforma y utiliza el potente compilador [[Free Pascal]] (FPC). FPC está disponible para más de 15 plataformas. No obstante lo anterior, no todas las librerías y paquetes están disponibles en todas ellas, Lazarus a día de hoy funciona en Linux (i386, x86_64), FreeBSD (i386), MacOSX (powerpc, i386) y Windows (i386, x86_64).
10	10
11	11		Lazarus no está terminado del todo, y del mismo modo, tampoco este texto. Se buscan nuevos programadores, escritores de paquetes, traductores, escritores de documentación, ...
12	12
13	13		### Lo primero que hay que hacer al convertir un proyecto de Delphi
14	14
15	15		Teniendo Lazarus en ejecución, tienes que ir a Herramientas y después a Convertir proyecto Delphi a proyecto Lazarus. Esto no lo hace todo, pero te facilitará la conversión. Tenga en cuenta que las herramientas disponibles en el IDE son unidireccionales. Si se necesita conservar la compatibilidad, para poder compilar indistintamente en Delphi y en Lazarus, considera convertir tus archivos utilizando [XDev Toolkit](http://wiki.lazarus.freepascal.org/XDev_Toolkit).
16	16
17	17		### Soporte para Unicode
18	18
19	19		Delphi, incluida la versión 2007, no da soporte para Unicode, utilizando la codificación ANSI de Windows. Delphi da soporte a Unicode utilizando codificación de cadenas en UTF-16 a partir de la versión 2009.
20	20
21	21		Por su lado Lazarus ha comenzado a dar soporte a Unicode con anterioridad y utiliza codificación de cadenas UTF-8. Para más información ver [[LCL Unicode Support\|Soporte LCL para Unicode]].
22	22
23	23		## Delphi IDE -\> Lazarus IDE
24	24
25	25		### Proyectos
26	26
27	27		El archivo de extensión .dpr es el principal de una aplicación Delphi. El archivo principal de un proyecto Lazarus es el de extensión .lpi (Información de proyecto Lazarus). El archivo .dpr es también el archivo principal de código y en el mismo el IDE almacena información sobre las opciones de compilación y las unidades que utiliza el proyecto. Una aplicación Lazarus también tiene un archivo .lpr, que es el archivo principal de código. El resto de la información se almacena en el .lpi. Por lo tanto el .lpi es el archivo más importante del proyecto.
28	28
29	29		Por ejemplo:
30	30
31	31		Delphi guarda las rutas a las unidades en el archivo .dpr. Como esta, unidad1 in 'ruta/Unidad1.pas'. El in es específico de Delphi y no es entendido por Lazarus. No lo utilices, en su lugar usa las opciones de unidades y rutas de configuración del compilador.
32	32
33	33		Delphi guarda las opciones del compilador, como {\$APPTYPE CONSOLE}, en el archivo .dpr, que son ignoradas por Lazarus. No lo utilices, en su lugar usa las opciones del compilador.
34	34
35	35		#### Una cuestión importante: Siempre hay un proyecto.
36	36
37	37		La única forma de "cerrar" un proyecto es cerrando Lazarus o abriendo otro proyecto. Esto es así, porque un proyecto Lazarus es así mismo una "sesión". Esto significa que la configuración actual del IDE se guarda en el archivo .lpi y es restaurada al reabrir el proyecto. Por ejemplo: estás depurando una aplicación, pones una serie de puntos de parada y marcas. Puedes guardar el proyecto, cerrar Lazarus o abrir otro proyecto. Cuándo reabras el proyecto, incluso en otra máquina, todos los puntos de parada, marcadores, archivos abiertos en el editor, posición de los cursores, historia de saltos, y demás, serán restaurados.
38	38
39	39		### Editor de Código
40	40
41	41		Casi todas las funciones asignadas a teclas y los accesos directos se puede definir en Entorno -\> Opciones del editor -\> Accesos rápidos.
42	42
43	43		El IDE de Lazarus tiene una gran cantidad de herramientas para trabajar con el código fuente. Muchas son parecidas y trabajan de forma similar a las de Delphi. Pero hay una diferencia importante, Lazarus no utiliza el compilador para obtener información del código, analiza el código fuente directamente. Esto tiene un montón de ventajas importantes:
44	44
45	45		El editor trabaja con "comentarios". Para Delphi los comentarios son simplemente espacios entre el código. Ninguna característica del código trabaja aquí y si se inserta automáticamente nuevo código, los comentarios se desplazan. Con Lazarus se puede encontrar una declaración de código incluso dentro de los comentarios. Aunque esto no es completamente fiable, normalmente funciona. Cuando se inserta nuevo código el IDE utiliza heurística para mantener los comentarios y el código juntos. Por ejemplo, no separará la línea:
46	46
47	47		``` pascal
48	48		letra: char; // comentario
49	49		```
50	50
51	51		La función de Completar código de Delphi (Ctrl+Space) se denomina Completar identificador (Identifier Completion) en Lazarus. El término Lazarus Completar código (Code Completion) es una funcionalidad que combina Completar Clase automáticamente (Automatic Class Completion igual que en Delphi), Completar variable local (Local Variable Completion) y Completar asignación de evento (Event Assignment Completion. Todas ellas se activan mediante Ctrl+Shift+C y el IDE determina cuál ejecutaraá en función del código presente en la posición del cursor.
52	52
53	53		#### Ejemplo de Completar variable local
54	54
55	55		Supongamos que acabas de crear un nuevo método y escribes la sentencia "i:=3;"
56	56
57	57		``` pascal
58	58		procedure TForm1.HacerAlgo;
59	59		begin
60	60		i := 3;
61	61		end;
62	62		```
63	63
64	64		Coloca el cursor justo de delante del identificador "i" y presiona Ctrl+Shift+C para obtener la declaración de la variable:
65	65
66	66		``` pascal
67	67		procedure TForm1.HacerAlgo;
68	68		var i: Integer;
69	69		begin
70	70		i := 3;
71	71		end;
72	72		```
73	73
74	74		#### Ejemplo Completar asignación de evento
75	75
76	76		Una buena característica del inspector de objetos es crear métodos automáticamente. Se puede hacer lo mismo en el editor de código.\
77	77		Por ejemplo:
78	78
79	79		``` pascal
80	80		btnCancelar.OnClick:=
81	81		```
82	82
83	83		Sitúa el cursor tras el operador de asignación ":=" y presiona Ctrl+Shift+C, y se generará el esqueleto de la función de respuesta al evento.
84	84
85	85		``` pascal
86	86		//...
87	87		btnCancelar.OnClick:=@btnCancelarClick;
88	88		//...
89	89
90	90		procedure Form1.btnCancelarClick(Sender : TObject);
91	91		begin
92	92
93	93		end;
94	94		```
95	95
96	96		#### Ejemplo de Completar llamada a Procedimiento
97	97
98	98		Supongamos que acabamos de escribir la sentencia "HacerAlgo(Ancho);" en este código
99	99
100	100		``` pascal
101	101		procedure UnProcedimiento;
102	102		var
103	103		Ancho: integer;
104	104		begin
105	105		Ancho:=3;
106	106		HacerAlgo(Ancho);
107	107		end;
108	108		```
109	109
110	110		Sitúa el cursor sobre el identificador "HacerAlgo" y presiona las teclas Ctrl+Shift+C para obtener:
111	111
112	112		``` pascal
113	113		procedure HacerAlgo(aAncho: LongInt);
114	114		begin
115	115
116	116		end;
117	117
118	118		//...
119	119
120	120		procedure UnProcedimiento;
121	121		var
122	122		Ancho: integer;
123	123		begin
124	124		Ancho:=3;
125	125		HacerAlgo(Ancho);
126	126		end;
127	127		```
128	128
129	129		Nota del traductor: lo descrito más arriba no funciona (da un error: Ya fue definido el identificador UnProcedimiento); sin embargo si el cursor está dentro del código de "UnProcedimiento", cómo en el ejemplo:
130	130
131	131		``` pascal
132	132		type
133	133		UnaClase = Class(TObject)
134	134		end;
135	135		//...
136	136		procedure UnaClase.UnProcedimiento;
137	137		begin
138	138		//...
139	139		end;
140	140		```
141	141
142	142		Al pulsar Ctrl+Shift+C obtendremos la definición de UnProcedimiento como miembro de la clase "UnaClase".
143	143
144	144		``` pascal
145	145		type
146	146		UnaClase = Class(TObject)
147	147		private
148	148		procedure UnProcedimiento;
149	149		end;
150	150		//...
151	151		procedure UnaClase.UnProcedimiento;
152	152		```
153	153
154	154		#### "Completar palabras" Ctrl+W
155	155
156	156		Trabaja de forma parecida a Completar identificador, sólo que no trabaja con identificadores pascal, sino con cualquier palabra. Busca en los ficheros abiertos todas las palabras que comienzan con las letras precedentes.
157	157
158	158		#### Borrar hasta el final de la línea: Ctrl+T
159	159
160	160		#### Borrar la línea completa: Ctrl+Y
161	161
162	162		#### [[IDE Window: Code Templates\|Acceder a las plantillas de código: Ctrl+J]]
163	163
164	164		#### Permite archivos de inclusión (include)
165	165
166	166		Mediante la directiva {\$i acrchivo.inc}. Delphi también permite usarlos (comprobado en D3 y D7, en D/ además se utiliza), aunque que probablemente no has creado muchos archivos de inclusión. Estos archivos tienen una gran ventaja: permiten escribir código (in)dependiente de la plataforma sin llenar el código de directivas IFDEF. Por ejemplo: Saltar al procedimiento (procedure jump), Completar clase, buscar declaración, ... funcionan con los archivos de inclusión.
167	167
168	168		Hay otras muchas opciones para trabajar con el código.
169	169
170	170		### Diseñador
171	171
172	172		- Directrices
173	173
174	174		#### Inspector de Objetos
175	175
176	176		En Delphi y Lazarus el Inspector de Objetos se utiliza para editar las propiedades de los componentes y la asignación de los eventos. Estas son lagunas de las pequeñas diferencias que hay entre ambos:
177	177
178	178		1. Con Delphi 5 apareció una vista jerarquizada en árbol de los componentes (Object Treeview), que se podía usar para moverse por los objetos y seleccionarlos, además de la tradicional lista desplegable del Inspector. En Lazarus esta vista de árbol está integrada en el Inspector y se utiliza en sustitución de la lista desplegable. Se puede activar o desactivar su utilización mediante la opción Mostrar Árbol de componentes del [menú contextual del Inspector](http://wiki.lazarus.freepascal.org/images/1/1f/Lazarus_Arbol_Inspector_Objetos.png) .
179	179		2. En Delphi haciendo doble clic en un evento vacío se crea este y se abre el Editor con el cursos en el mismo, en Lazarus, además de lo anterior, existe un botón al lado de la lista desplegable que hace lo mismo.
180	180		3. En Delphi se puede borrar manualmente el nombre de un evento para deshacer el enlace, en Lazarus, además podemos seleccionar (none) en la lista desplegable.
181	181		4. De forma similar, con doble clic en propiedades corrientes, cómo un lógico cambia su valor, además podemos seleccionarlo con la lista desplegable. Si la propiedad requiere de editor especializado, aparecerá este, al igual que si usamos el botón con los puntos suspensivos.
182	182
183	183		#### Paquetes
184	184
185	185		¿Se pueden instalar y usar paquetes Delphi en Lazarus?
186	186
187	187		No de forma directa, porque necesitan la magia del compilador de Delphi.
188	188
189	189		¿Necesitamos entonces paquetes específicos para Lazarus ?
190	190
191	191		Sí, para ello:
192	192
193	193		Crea un nuevo paquete, guárdalo en el direcorio donde residen los archivos fuente (normalmente el mismo directorio del archivo .dpk), añade la LCL cómo paquete necesario y finalmente los archivos .pas. Ya puedes instalarlo o utilizarlo en tus proyectos. Hay algunas diferencias entre los paquetes de Lazarus y Delphi, leete el archivo docs/Packages.txt que se encuentra en el directorio de fuentes de Lazarus.
194	194
195	195		Ver tambien la [[Code Conversion Guide/es\|Guía de conversión de código entre Delphi y Lazarus]]
196	196
197	197		### VCL -\> LCL
198	198
199	199		Aunque laVCL y la LCL sirven en gran parte para el mismo propósito, una jerarquía de componentes orientada a objetos enfocada especialmente hacia el desarrollo rápido de aplicaciones, no son idénticas. Por ejemplo mientras que la VCL proporciona muchos componentes no visuales, el LCL procura proveer solamente componentes visuales, mientras que la mayoría de los componentes no visuales (tales como el acceso a BD) son proporcionados por la FCL, incluida con [[Free Pascal]].
200	200
201	201		Así mismo la LCL no tiene de algunos controles disponibles en la VCL o al contrario, o cuándo tiene el mismo control estos no son idénticos, y por tanto hay que realizar cambios en aplicaciones, componentes y controles al migrar.
202	202
203	203		Lo que sigue es una tentativa de proporcionar descripciones bastante completas de la diferencias principales o de incompatibilidades entre los dos para el usuario de Delphi. Se cubren las diferencias primordialmente con la VCL de D4, aunque ocasionalmente también con las de D5, D6, o D7 ; y con la LCL actual, tal como está en el CVS. No podemos asegurar la coincidencia con la LCL de que cada uno dispone, ni cuál es la versión de Delphi de la que cada uno viene, por lo que si se ven discrepancias se es libre de añadir o modificar lo que sea necesario con el fin de mantener este documento tan comprensible como sea posible para todo el mundo.
204	204
205	205		#### TControl.Font/TControl.ParentFont
206	206
207	207		En la VCL es muy común y normal utilizar un tipo de letra y propiedades de fuente, como negrita y cursiva para los controles y se espera que este valor sea usado siempre. Más adelante se proporciona la característica de TControl.ParentFont que se asegura de que un control siga siempre la fuente de su padre. Otra vez se asume que estos valores serán seguidos siempre, incluso ignorando los ajustes de en la apariencia de Windows.
208	208
209	209		Esto no es siempre cierto en la LCL, ni lo puede ser. La LCL que es por naturaleza múltiplataforma-multiinterfaz prefiere hacer una acercamiento equilibrado, y en su lugar intentará siempre utilizar los ajustes nativos de la apariencia del escritorio y el tema utilizado en los controles. Por ejemplo si usa un interfaz de GTK, y el tema del gtk dispone una fuente específica para los botones, los botones de la LCL procurarán siempre utilizar esta fuente.
210	210
211	211		Esto significa que la mayoría de los controles de LCL no tienen el mismo nivel de ajuste del diseño que se espera a menudo en el VCL, solamente los controles personalizados que sean dibujados en el lienzo (canvas) y no creados por la interfaz pueden modificar consistentemente este interfaz asignado, sin importar cual sea el interfaz usado.
212	212
213	213		#### Arrastre y colocación de controles
214	214
215	215		En la VCL muchos (win)controles tienen métodos y funciones de retrollamada para habilitar el arrastre y colocación de los mismos, v.g. arrastrar un control desde un panel y colocarlo en otro panel en tiempo de ejecución.
216	216
217	217		Esta funcionalidad no está implementada y está inacabada normalmente en la LCL,aunque está actualmente en las etapas iniciales de estudio, y debe aportar un cierto nivel de compatibilidad para este tipo de comportamiento, aunque no exactamente de la misma manera.
218	218
219	219		Esto significa actualmente que ningún control hereda/utiliza las funciones, procedimientos, propiedades o eventos de TControl siguientes:
220	220
221	221		``` pascal
222	222		Protected
223	223		function GetDockEdge(MousePos: TPoint): TAlign;
224	224		function GetDragImages: TDragImageList;
225	225		function GetFloating: Boolean;
226	226		function GetFloatingDockSiteClass: TWinControlClass;
227	227		procedure DoEndDrag(Target:TObject); X, Y: Integer);
228	228		procedure DockTrackNoTarget(Source: TDragDockObject; X, Y: Integer);
229	229		procedure DoEndDock(Target: TObject; X, Y: Integer);
230	230		procedure DoDock(NewDockSite: TWinControl; var ARect: TRect);
231	231		procedure DoStartDock(var DragObject: TDragObject);
232	232		procedure DragCanceled;
233	233		procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
234	234		var Accept: Boolean);
235	235		procedure DoEndDrag(Target: TObject; X, Y: Integer);
236	236		procedure DoStartDrag(var DragObject: TDragObject);
237	237		procedure DrawDragDockImage(DragDockObject: TDragDockObject);
238	238		procedure EraseDragDockImage(DragDockObject: TDragDockObject);
239	239		procedure PositionDockRect(DragDockObject: TDragDockObject);
240	240		procedure SetDragMode(Value: TDragMode);
241	241		property DragKind: TDragKind;
242	242		property DragCursor: TCursor;
243	243		property DragMode: TDragMode;
244	244		property OnDragDrop: TDragDropEvent;
245	245		property OnDragOver: TDragOverEvent;
246	246		property OnEndDock: TEndDragEvent;
247	247		property OnEndDrag: TEndDragEvent;
248	248		property OnStartDock: TStartDockEvent;
249	249		property OnStartDrag: TStartDragEvent;
250	250		public
251	251		function Dragging: Boolean;
252	252		function ManualDock(NewDockSite: TWinControl; DropControl: TControl;
253	253		ControlSide: TAlign): Boolean;
254	254		function ManualFloat(ScreenPos: TRect): Boolean;
255	255		function ReplaceDockedControl(Control: TControl; NewDockSite: TWinControl;
256	256		DropControl: TControl; ControlSide: TAlign): Boolean;
257	257		procedure BeginDrag(Immediate: Boolean; Threshold: Integer);
258	258		procedure Dock(NewDockSite: TWinControl; ARect: TRect);
259	259		procedure DragDrop(Source: TObject; X, Y: Integer);
260	260		procedure EndDrag(Drop: Boolean);
261	261		property DockOrientation: TDockOrientation;
262	262		property Floating: Boolean;
263	263		property FloatingDockSiteClass: TWinControlClass;
264	264		property HostDockSite: TWinControl;
265	265		property LRDockWidth: Integer;
266	266		property TBDockHeight: Integer;
267	267		property UndockHeight: Integer;
268	268		property UndockWidth: Integer;
269	269		```
270	270
271	271		que las clases siguientes no existen/o no son utilizables
272	272
273	273		``` pascal
274	274		TDragImageList = class(TCustomImageList)
275	275		TDockZone = class
276	276		TDockTree = class(TInterfacedObject, IDockManager)
277	277		TDragObject = class(TObject)
278	278		TBaseDragControlObject = class(TDragObject)
279	279		TDragControlObject = class(TBaseDragControlObject)
280	280		TDragDockObject = class(TBaseDragControlObject)
281	281		```
282	282
283	283		y que las siguientes funciones no son utilizables o son incompablibles
284	284
285	285		``` pascal
286	286		function FindDragTarget(const Pos: TPoint;
287	287		AllowDisabled: Boolean) : TControl;
288	288		procedure CancelDrag;
289	289		function IsDragObject(sender: TObject): Boolean;
290	290		```
291	291
292	292		El inicio del controlador de ajuste se describe aquí: [[Anchor Docking]]
293	293
294	294		#### TEdit/TCustomEdit
295	295
296	296		Los controles Edit, funcionan esencialmente de la misma forma en la LCL y en la VCL, aunque tienen algunas cuestiones de las que ser conscientes a la hora de convertir.
297	297
298	298		1. Debido a restricciones en los interfaces, TEdit.PasswordChar no trabaja en todos los interfaces (con el tiempo puede que sí), en su lugar se puede utilizar emPassword de TCustomEdit.EchoMode para el texto que necesite ser ocultado.
299	299		2. Los eventos Drag/Dockno están implementados. Para más información ver la sección Arrastre y colocación de controles.
300	300		3. Las propiedades de Font son normalmente ignoradas para consistencia del interfaz, para una explicación detallada ver la sección TControl.Font/TControl.ParentFont
301	301
302	302		### (optional) TSplitter -\> TPairSplitter
303	303
304	304		Mejórame, por favor
305	305
306	306		Ya existe un control TSplitter en la LCL, por lo que no es necesaria la conversión. Sin embargo, si usted quiere hacerlo, aquí se explica cómo:
307	307
308	308		Lo que sigue se basa libremente en preguntas de Vincent Snijders en la lista de correo, y en las respuestas de [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson):
309	309
310	310		En la VCL el control "repartidor", que es como un [tirador](http://buscon.rae.es/draeI/SrvltGUIBusUsual?TIPO_HTML=2&TIPO_BUS=3&LEMA=tirador) que se coloca entre dos componentes para distribuir el espacio entre ambos, está representado por TSplitter. Esto se ve a menudo, por ejemplo en el IDE de Delphi entre el explorador del código y el visor de código fuente.
311	311
312	312		La LCL proporciona su propio control llamado TPairSplitter, que sirve para el mismo propósito, no obstante no es compatible, será necesario "reparar" el código de los DFM de Delphi convertidos, aunque gran parte es compartido entre los dos.
313	313
314	314		¿Cuales son exactamente las diferencias?
315	315
316	316		La mayor diferencia es que el TSplitter de la VCL no tiene hijos, en vez de ello se coloca entre los dos controles alineados apropiadamente y modifica sus dimensiones en tiempo de ejecución. Es necesario tener dos controles alineados para cualquier cosa. Un ejemplo sencillo es un formulario con un Panel alineado a la izquierda (Aling := alLeft), un Splitter alineado a la izquierda y un segundo panel alineado al área cliente (Aling := alClient). Durante la ejecución puede ajustar el espacio entre los dos paneles arrastrando el tirador que provee el control Splitter.
317	317
318	318		En la LCL, por su parte, un TPairSplitter es un tipo especial de control con dos paneles, y aunque es útil únicamente si los controles que se reparten el espacio están en ellos, realiza su cometido estando vacios. Siguiendo con el ejemplo anterior, tendríamos un formulario con un TPairSplitter alineado al área cliente (Aling := alClient) y sendos paneles, igualmente alineados al área cliente (Aling := alClient) a los lados.
319	319
320	320		La otra diferencia importante es que en la VCL, puesto que el TSplitter es su propio TControl, la posición se guarda relativa a los otros controles al hacer el reparto, así que en cierto momento un panel del cliente crecerá mientras que los otros paneles no, así la posición de la frontera es relativa a la alineación de los controles participantes.
321	321
322	322		En la LCL puesto que los paneles laterales están separados el control TPairSplitter tiene su propiedad de posición es absoluta, y al realizar la redistribución no cambia su posición según el contenido, por lo que hay que hacer una retrollamada para asegurar que se mantiene el ratio, en caso de ser importante.
323	323
324	324		Por ejemplo, si el lado derecho de una distribución vertical necesita comportase como si estuviera alineado al cliente será necesario añadir al evento OnResize del formulario código cómo este:
325	325
326	326		``` pascal
327	327		PairSplitter.Position := PairSplitter.Width - PairSplitter.Position;
328	328		```
329	329
330	330		¿Cómo puedo convertir código existente que utiliza TSplitter a TPairSplitter?
331	331
332	332		Si el repartidor y los controles se crean dentro de una función (como OnCreate del formulario), la conversión será más difícil, se reorganiza primero el código para crear los controles en el orden adecuado según la nueva jerarquía y para fijar a los padres de los controles hijo a repartir de izquierda/arriba y a la derecha/abajo del PairSplitter. Un ejemplo de los cambios necesarios:
333	333
334	334		VCL
335	335
336	336		LCL
337	337
338	338		``` pascal
339	339		var
340	340		BottomPanel: TPanel;
341	341		VerticalSplitter: TSplitter;
342	342		LeftPanel: TPanel;
343	343		HorizontalSplitter: TSplitter;
344	344		MainPanel: TPanel;
345	345
346	346		begin
347	347		BottomPanel:= TPanel.Create(Self);
348	348		with (BottomPanel) do
349	349		begin
350	350		Parent:= Self;
351	351		Height:= 75;
352	352		Align:= alBottom;
353	353		end;
354	354
355	355		VerticalSplitter:= TSplitter.Create(Self);
356	356		with (VerticalSplitter) do
357	357		begin
358	358		Parent:= Self;
359	359		Align:= alBottom;
360	360		end;
361	361
362	362		HorizontalSplitter:= TSplitter.Create(Self);
363	363		with (HorizontalSplitter) do
364	364		begin
365	365		Parent:= Self;
366	366		align:= alLeft;
367	367		end;
368	368
369	369		LeftPanel:= TPanel.Create(Self);
370	370		with (LeftPanel) do
371	371		begin
372	372		Parent:= Self;
373	373		Width:= 125;
374	374		Align:= alLeft;
375	375		end;
376	376
377	377		MainPanel:= TPanel.Create(Self);
378	378		with (MainPanel) do
379	379		begin
380	380		Parent:= Self;
381	381		Align:= alClient;
382	382		Caption:= 'Hello';
383	383		end;
384	384		end;
385	385		```
386	386
387	387		``` pascal
388	388		var
389	389		BottomPanel: TPanel;
390	390		VerticalSplitter: TPairSplitter;
391	391		LeftPanel: TPanel;
392	392		HorizontalSplitter: TPairSplitter;
393	393		MainPanel: TPanel;
394	394
395	395		begin
396	396		VerticalSplitter:= TPairSplitter.Create(Self);
397	397		with (VerticalSplitter) do
398	398		begin
399	399		Parent:= Self;
400	400		Align:= alClient;
401	401		Width:= Self.Width;
402	402		Height:= Self.Height;
403	403		SplitterType:= pstVertical;
404	404		Position:= Height - 75;
405	405		Sides[0].Width:= Width;
406	406		Sides[0].Height:= Position;
407	407		end;
408	408
409	409		HorizontalSplitter:= TPairSplitter.Create(Self);
410	410		with (HorizontalSplitter) do
411	411		begin
412	412		Parent:= VerticalSplitter.Sides[0];
413	413		Width:= Self.Width;
414	414		Height:= VerticalSplitter.Position;
415	415		align:= alClient;
416	416		SplitterType:= pstHorizontal;
417	417		Position:= 125;
418	418		end;
419	419
420	420		LeftPanel:= TPanel.Create(Self);
421	421		with (LeftPanel) do
422	422		begin
423	423		Parent:= HorizontalSplitter.Sides[0];
424	424		Align:= alClient;
425	425		end;
426	426
427	427		MainPanel:= TPanel.Create(Self);
428	428		with (MainPanel) do
429	429		begin
430	430		Parent:= HorizontalSplitter.Sides[1];
431	431		Align:= alClient;
432	432		Caption:= 'Hello';
433	433		end;
434	434
435	435		BottomPanel:= TPanel.Create(Self);
436	436		with (BottomPanel) do
437	437		begin
438	438		Parent:= VerticalSplitter.Sides[1];
439	439		Align:= alClient;
440	440		end;
441	441		end;
442	442		```
443	443
444	444		Hay que ser consistente con la jerarquía de los controles. Y si se está familiarizado con los DFM' s, los cambios necesarios para la conversión DFM-\>LFM serán obvios cómo los anteriores, pues son del mismo tipo para las propiedades Parent/Owner, etc. El ejemplo sería algo así:
445	445
446	446		Delphi DFM
447	447
448	448		(valores ajenos elliminados)
449	449
450	450		Lazarus LFM
451	451
452	452		*(algunos width, height, etc. eliminados)*
453	453
454		-	~~``` pascal~~
	454	+	``` lfm
455	455		object RepartidorVertical: TSplitter
456	456		Height = 3
457	457		Cursor = crVSplit
458	458		Align = alBottom
459	459		end
460	460		object RepartidorHorizontal: TSplitter
461	461		Width = 3
462	462		Align = alLeft
463	463		end
464	464		object Panel_Inferior: TPanel
465	465		Height = 75
466	466		Align = alBottom
467	467		end
468	468		object Panel_Izquierdo: TPanel
469	469		Width = 125
470	470		Align = alLeft
471	471		end
472	472		object Panel_Principal: TPanel
473	473		Align = alClient
474	474		end
475	475		```
476	476
477		-	~~``` pascal~~
	477	+	``` lfm
478	478		object RepartidorVertical: TPairSplitter
479	479		Height = 154
480	480		Width = 362
481	481		Position = 45
482	482		SplitterType = pstVertical
483	483		object Panel_Superior: TPairSplitterSide
484	484		Height = 45
485	485		Width = 362
486	486		end
487	487		object Panel_Inferior: TPairSplitterSide
488	488		Height = 103
489	489		Width = 362
490	490		ClientWidth = 362
491	491		ClientHeight = 103
492	492		object PairSplitter1: TPairSplitter
493	493		Height = 103
494	494		Width = 362
495	495		Align = alClient
496	496		Position = 45
497	497		object Panel_Izquierdo: TPairSplitterSide
498	498		Height = 103
499	499		Width = 45
500	500		end
501	501		object Panel_Derecho: TPairSplitterSide
502	502		Height = 103
503	503		Width = 311
504	504		end
505	505		end
506	506		end
507	507		end
508	508		```
509	509
510	510		### TCustomTreeView/TTreeView
511	511
512	512		Tanto la VCL como la LCL disponen de un componente TCustomTreeView/TTreeView, utilizados para mostrar listas en forma de árboles estructurados con múltiples nodos, selección avanzada y lista de imágenes; y aunque las funcionalidades don comparables, no todas las propiedades son completamente compatibles. Las principales diferencias son estas:
513	513
514	514		*La lista no está completa, es necesario actualizar para incluir las funciones TCustomTreeView Marky los métodos protegridos*
515	515
516	516		1. La LCL provee TCustomTreeView.Options, un conjunto de opciones con cuyos valores podemos cambiar el comportamiento y la apariencia del control. Estas opciones son:
517	517		- tvoAllowMultiselect- habilita el modo de selección múltiple, equivalente a TCustomTreeView.MultiSelecten VCL de D6.
518	518		- tvoAutoExpand - Expandir nodos automáticamente, equivalente a TCustomTreeView.AutoExpand.
519	519		- tvoAutoInsertMark - Actualizar la vista de arrastre al mover el ratón.
520	520		- tvoAutoItemHeight - Ajustar la altura de los elementos automáticamente.
521	521		- tvoHideSelection'' - No marcar el elemento seleccionado.
522	522		- "tvoHotTrack- usarHot Tracking, equivalente aTCustomTreeview.HotTrack''
523	523		- "tvoKeepCollapsedNodes'' - Mantener los nodos hijos al cerrar o abrir.
524	524		- "tvoReadOnly- Poner el componente en modo sólo lectura, equivalente aTCustomTreeview.ReadOnly''
525	525		- "tvoRightClickSelect- habilitar la selección de nodos con el botón derecho del ratón, equivalente aTCustomTreeView.RightClickSelect''.
526	526		- "tvoRowSelect - habilitar la selección de columnas, equivalente aTCustomTreeView.RowSelect.''
527	527		- "tvoShowButtons - mostrar botones, equivalente aTCustomTreeView.ShowButtons''.
528	528		- "tvoShowLines- mostrar líneas de nodos, equivalente aTCustomTreeView.ShowLines''.
529	529		- "tvoShowRoot - mostrar nodo raíz, equivalente aTCustomTreeView.ShowRoot''.
530	530		- "tvoShowSeparators '' - mostrar separadores.
531	531		- "tvoToolTips'' - mostrar ayudas para nodos individuales.
532	532		2. La LCL provee propiedades adicionales:
533	533		- Evento TCustomTreeView.OnSelectionChange.
534	534		- "tCustomTreeView.DefaultItems'', para el número de elementos predeterminados.
535	535		- "tCustomTreeView.ExpandSignType'' para elegir el signo utilizado para indicar los nodos expandibles o contraibles.
536	536		3. La mayor parte de los eventos de Arrastrar y soltar (Drag/Dock) están disponibles en la LCL, aunque no funcionan. Para más información ver la sección precedente sobre Arrastre y colocación de controles.
537	537
538	538		### Mensajes y Eventos
539	539
540	540		El orden y la frecuencia de los mensajes y eventos (OnShow, OnActivate, OnEnter, ...) de la LCL son diferentes de los de la VCL y dependen de la interfaz utilizada.
541	541
542	542		La LCL dispone de un subconjunto de mensajes similares a los de winAPI para hacer la migración desde Delphi sencilla, pero muchos mensajes de la LCL operan de forma diferente a sus pares de la VCL/winAPI. La mayor parte del código de Delphi utiliza mensajes winAPI,porque el VCL carece de esa característica o por razones de velocidad. Este tipo de código ráramente funcionará igual con la LCL, así que debe ser comprobado manualmente. Esto es así, ya que los mensajes de LCL se llaman por ejemplo LM_SIZE en vez de WM_SIZE (unidad lmessages).
543	543
544	544		## Colaboradores originales y cambios
545	545
546	546		Esta página a sido convertida desde la [versión de la epikwiki](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusForDelphiUsers).
547	547
548	548		- Versión incial de la adaptación por VlxAdmin 9/26/2003
549	549		- Begin VCL -\> LCL with a section on TSplitter -\> TPairSplitter - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/30/2003
550	550		- Add TControl.Font/TControl.ParentFont to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/30/2003
551	551		- Update TEdit/TCustomEdit section in VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
552	552		- Add Control Dragging/Docking to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
553	553		- Added "Object Inspector" to Delphi IDE -\> Lazarus IDE - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
554	554		- Added initial "TCustomTreeView/TTreeView" to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
555	555		- Added introduction to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003
556	556		- Fixed some typos - Vincent 10/2/2003
557	557		- Fixed Typo User:Kirkpatc 20 May 2004
558	558		- Versión en castellano (español) iskraelectrica (jldc) / junio de 2008.
559	559
560	560		## Ver también
561	561
562	562		[[Code Conversion Guide/es\|Guía de conversión de código (desde Delphi y Kylix)]]
563	563
564	564		[[Compile With Delphi\|Compilar con Delphi]]
565	565
566	566		---
567	567		From the Free Pascal wiki, page "Lazarus For Delphi Users/es", as it stood on 2020-02-18 after a change by Trev, 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).
568	568		Category: Castellano
569	569		Category: Español

Back to history