Lazarus IDE Tools/es: what changed

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

Old	New		Line
1	1		## Descripción general
2	2
3	3		El IDE de Lazarus utiliza una librería llamada *codetools* para analizar y editar el código fuente pascal. Estas herramientas ofrece funciones para completar código, extraer, mover, insertar y embellecer el código pascal. Utilizarlas permite ahorrar mucho tiempo y evitar duplicar esfuerzos. Son configurables y cada una de las funciones es accesible mediante un atajo (ver Editor Options).
4	4
5	5		Al trabajar únicamente con código fuente pascal (de FPC, Delphi y Kylix) no necesita unidades compiladas ni instalar el compilador Borland. Se puede editar código Delphi y FPC a la vez. Incluso se puede trabajar con varias versiones de Delphi y FPC al tiempo. Todo lo anterior hace la conversión de código Delphi mucho más fácil.
6	6
7	7		## Tabla resumen de los atajos
8	8
9	9		\| \| \|
10	10		\|----\|----\|
11		-	~~\| Buscar Declaración \| <span class="kbd">Ctrl</span>+Click o <span class="kbd">Alt</span>+<span class="kbd">Up</span> (Salta a la declaración de la variable) \|~~
12		-	~~\| Salto a Procedimiento \| <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> (Salta entre la definición y el cuerpo de procedimientos y funciones) \|~~
13		-	~~\| Plantillas de Código \| <span class="kbd">Ctrl</span>+<span class="kbd">J</span> \|~~
14		-	~~\| Edición sincronizada \| <span class="kbd">Ctrl</span>+<span class="kbd">J</span> (cuándo hay texto seleccionado) \|~~
15		-	~~\| Completar Código \| <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> (Completar Clase) \|~~
16		-	~~\| Completar Identificador \| <span class="kbd">Ctrl</span>+<span class="kbd">space</span> \|~~
17		-	~~\| Completar Palabra \| <span class="kbd">Ctrl</span>+<span class="kbd">W</span> \|~~
18		-	~~\| Sugerencia de Parámetros \| <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">space</span> \|~~
19		-	~~\| [[Incremental Search\|Búsqueda incremental]] \| <span class="kbd">Ctrl</span>+<span class="kbd">E</span> \|~~
	11	+	\| Buscar Declaración \| `Ctrl`+Click o `Alt`+`Up` (Salta a la declaración de la variable) \|
	12	+	\| Salto a Procedimiento \| `Ctrl`+`Shift`+`Up` (Salta entre la definición y el cuerpo de procedimientos y funciones) \|
	13	+	\| Plantillas de Código \| `Ctrl`+`J` \|
	14	+	\| Edición sincronizada \| `Ctrl`+`J` (cuándo hay texto seleccionado) \|
	15	+	\| Completar Código \| `Ctrl`+`Shift`+`C` (Completar Clase) \|
	16	+	\| Completar Identificador \| `Ctrl`+`space` \|
	17	+	\| Completar Palabra \| `Ctrl`+`W` \|
	18	+	\| Sugerencia de Parámetros \| `Ctrl`+`Shift`+`space` \|
	19	+	\| [[Incremental Search\|Búsqueda incremental]] \| `Ctrl`+`E` \|
20	20
21	21		## Salto a Procedimiento
22	22
23		-	Para ir desde el cuerpo de un procedimiento (o función) al lugar donde está su declaración (procedure Nombre;), o viceversa se utiliza la combinación de teclas <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>.
	23	+	Para ir desde el cuerpo de un procedimiento (o función) al lugar donde está su declaración (procedure Nombre;), o viceversa se utiliza la combinación de teclas `Ctrl`+`Shift`+`Up`.
24	24
25	25		Por ejemplo:
26	26
27	27		``` pascal
28	28		interface
29	29		procedure HacerAlgo; // declaración del procedimiento
30	30		//...
31	31		implementation
32	32		//...
33	33		procedure HacerAlgo; // Cuerpo del procedimiento
34	34		begin
35	35		//...
36	36		end;
37	37		```
38	38
39		-	Si el cursor está en cualquier parte del cuerpo del procedimiento y se pulsan las teclas Ctrl+Shift+Up, el cursor salta a la declaración. Volviendo a pulsar <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> se regresa al cuerpo, y el cursor se sitúa al principio de la primera línea trás el begin.
	39	+	Si el cursor está en cualquier parte del cuerpo del procedimiento y se pulsan las teclas Ctrl+Shift+Up, el cursor salta a la declaración. Volviendo a pulsar `Ctrl`+`Shift`+`Up` se regresa al cuerpo, y el cursor se sitúa al principio de la primera línea trás el begin.
40	40
41	41		Esto funciona con procedimientos y funciones, sean o no miembros de una clase.
42	42
43	43		Nota: 'Salto a Procedimiento' busca el procedimiento (o función) con el mismo nombre y lista de parámetros. Si no existe coincidencia exacta, salta al mejor candidato y situa el cursor en la primera diferencia que encuentra. (Delphi solo busca la coincidencia exacta, en D7 al menos).
44	44
45	45		Por ejemplo una función con diferente lista de parámetros:
46	46
47	47		``` pascal
48	48		interface
49	49
50	50		function HacerAlgo(p: char); // declaración de la función
51	51
52	52		implementation
53	53
54	54		function HacerAlgo(p: string); // cuerpo de la función
55	55		begin
56	56		end;
57	57		```
58	58
59	59		El salto desde la definición al cuerpo posicionará el cursor delante de la palabra clave string. Esto puede sernos útil para renombrar métodos y/o cambiar sus parámetros.
60	60
61	61		Por ejemplo:\
62	62		Remombramos 'HacerAlgo' a 'Hazlo':
63	63
64	64		``` pascal
65	65		interface
66	66
67	67		procedure Hazlo; // declaración del procedimiento
68	68
69	69		implementation
70	70
71	71		procedure HacerAlgo; // Cuerpo del procedimiento
72	72		begin
73	73		end;
74	74		```
75	75
76	76		Ahora saltamos desde el redefinido Hazlo al cuerpo. El IDE buscará un cuerpo que se corresponda, al no encontrarlo buscará un candidato plausible. Trás cambiar el nombre existe un único procedimiento sin su declaración (HacerAlgo), por lo que saltará a él, situando el cursor justo delante de "HacerAlgo". Ahora solo resta escribir el nuevo nombre. También funciona si hemos cambiado algo en la lista de parámetros.
77	77
78	78		## Archivos de inclusión
79	79
80	80		El contenido de los archivos de inclusión es insertado en el código fuente con las directivas de compilación {\$I NombreArchivo} o {\$INCLUDE NombreArchivo}. Lazarus y FPC utiliza una gran cantidad de ellos para reducir la redundancia y eliminar estructuras ilegibles con {\$IFDEF} que dan soporte a múltiples plataformas.
81	81
82	82		El IDE de Lazarus da soporte completo a los archivos de inclusión, al contrario que Delphi. Se puede saltar desde la declaración de un método en un .pas a su cuerpo en un archivo de inclusión. Todas las funciones de codetools consideran los archivos de inclusión un ámbito especial, tal cómo hace Completar Código.
83	83
84	84		Por ejemplo: Cuándo Completar Código añade el cuerpo de un nuevo método tras el cuerpo de otro, mantiene ambos en el mismo archivo. Así podemos poner la implementación completa de la clase en el archivo de inclusión, tal cómo se hace en la LCL para todos sus componentes.
85	85
86	86		Pero aquí hay una trampa para novatos: Si se abre un archivo de inclusión por primera vez y se usa Procedure Jump o Buscar Declaración se obtiene un eror. El IDE no sabe la unidad a la que pertenece el archivo de inclusión; hay que abrir la unidad previamente pra que la cosa funcione.
87	87
88	88		Tan pronto como el IDE analiza la unidad, se evalúan las directivas de inclusión y el IDE toma nota de las relaciones entre los archivos.Al cerrar o guardar el proyecto esta información se guarda en el archivo \$(LazarusDir)/includelinks.xml. La próxima vez que abramos el archivo de inclusión y realicemos un Procedure Jump o Buscar Declaración el IDE hará uso de esta información y las funciones trabajarán correctamente.
89	89
90	90		Este mecanismo tiene límites, por supuesto. Algunos archivos están incluidos dos o más veces, por ejemplo, \$(LazarusDir)/lcl/include/winapih.inc.
91	91
92	92		Los saltos a los cuerpos desde las definiciones de procedimientos o métodos desde este fichero dependerán del contexto actual. Si se está trabajando con lcl/lclintf.pp el IDE saltará a winapi.inc. Si se está trabajando con lcl/interfacebase.pp, el salto se realizará a lcl/include/interfacebase.inc (u otro archivo de inclusión). Si se está trabajando con los dos, habrá una situación ambigua. ;)
93	93
94	94		## Plantillas de código
95	95
96	96		Las Plantillas de código permiten convertir un identificador en un texto o en un fragmento de código.
97	97
98		-	El atajo, por defecto, para las Plantillas de código es <span class="kbd">Ctrl</span>+<span class="kbd">J</span>. Se escribe un identificador, se pulsan las teclas <span class="kbd">Ctrl</span>+<span class="kbd">J</span> y el identificador es sustituido por el texto definido para el identificador. Las Plantillas de código se definen en Entorno -\> Plantillas de Código....
	98	+	El atajo, por defecto, para las Plantillas de código es `Ctrl`+`J`. Se escribe un identificador, se pulsan las teclas `Ctrl`+`J` y el identificador es sustituido por el texto definido para el identificador. Las Plantillas de código se definen en Entorno -\> Plantillas de Código....
99	99
100		-	Ejemplo: Escribimos el identificador 'classf', con el cursor justo a la derecha de la 'f' pulsamos las teclas <span class="kbd">Ctrl</span>+<span class="kbd">J</span> y 'classf' será reemplazado por
	100	+	Ejemplo: Escribimos el identificador 'classf', con el cursor justo a la derecha de la 'f' pulsamos las teclas `Ctrl`+`J` y 'classf' será reemplazado por
101	101
102	102		``` pascal
103	103		TClass = class(TBase)
104	104		private
105	105
106	106		public
107	107		constructor Create;
108	108		destructor Destroy; override;
109	109		end;
110	110		```
111	111
112	112		además el cursor de posicionará en 'TClass'.
113	113
114	114		Podemos desplegar la lista de plantillas disponibles, situando el cursor en un espacio (no en un identificador) y pulsando las teclas Ctrl+J. Aparecerá la lista de plantillas. HAciendo uso de las teclas de dirección o escribiendo algo seleccionaremos una de ellas. Con intro usaremos la plantilla elegida y con escape cerraremos la lista sin hacer nada.
115	115
116		-	~~La plantilla que más tiempo nos ahorrará es 'b'+<span class="kbd">Ctrl</span>+<span class="kbd">J</span> para begin..end.~~
	116	+	La plantilla que más tiempo nos ahorrará es 'b'+`Ctrl`+`J` para begin..end.
117	117
118	118		## Sugerencia de Parámetros
119	119
120	120		Sugerencia de Parámetros muestra una caja con la lista de posibles declaraciones con sus parámetros para el procedimiento o función actual.
121	121
122	122		Por ejemplo:
123	123
124	124		``` pascal
125	125		Canvas.FillRect(\|);
126	126		```
127	127
128		-	Situamos el cursor dentro de los paréntesis y pulsamos <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">space</span>. La lista de sugerencias aparecerá con los posibles parámetros, según las distintas declaraciones de FillRect.
	128	+	Situamos el cursor dentro de los paréntesis y pulsamos `Ctrl`+`Shift`+`space`. La lista de sugerencias aparecerá con los posibles parámetros, según las distintas declaraciones de FillRect.
129	129
130		-	~~<figure>~~
131		-	~~<img src="Parameterhints1.png" title="Parameterhints1.png" />~~
132		-	~~<figcaption>Parameterhints1.png</figcaption>~~
133		-	~~</figure>~~
	130	+	![](/wiki-images/c/c8/Parameterhints1.png)
134	131
135	132		Desde la versión 0.9.31 hay un botón a la derecha de cada declaración para insertar el parámetro. Esto copiará los nombres de los parámetros de la declaración elegida en la posición del cursor.
136	133
137		-	~~<figure>~~
138		-	~~<img src="Parameterhints2.png" title="Parameterhints2.png" />~~
139		-	~~<figcaption>Parameterhints2.png</figcaption>~~
140		-	~~</figure>~~
	134	+	![](/wiki-images/4/48/Parameterhints2.png)
141	135
142	136		Consejo: Utiliza Completar Declaración de Variable para declarar las variables.
143	137
144	138		Nota: El nombre del atajo es "Show code context" (Mostrar Contexto del Código).
145	139
146	140		## Búsqueda incremental
147	141
148		-	Búsqueda incremental cambia la barra de estado del editor. Escribe algunos caracteres y el editor buscará y resaltará de inmediato todas las ocurrencias en el texto. El atajo es <span class="kbd">Ctrl</span>+<span class="kbd">e</span>.
	142	+	Búsqueda incremental cambia la barra de estado del editor. Escribe algunos caracteres y el editor buscará y resaltará de inmediato todas las ocurrencias en el texto. El atajo es `Ctrl`+`e`.
149	143
150		-	~~- Por ejemplo pulsa <span class="kbd">e</span> buscará y resaltará todas las apariciones de 'e'.~~
151		-	~~- Pulsa <span class="kbd">t</span> buscará y resaltará todas las apariciones de 'et' y así sucesivamente.~~
152		-	- Puede saltar a la siguiente con <span class="kbd">F3</span> (o <span class="kbd">Ctrl</span>+<span class="kbd">e</span> mientras se busca) y a la previa con <span class="kbd">Shift</span>+<span class="kbd">F3</span>.
153		-	~~- <span class="kbd">Backspace</span> elimina el último carácte~~
154		-	~~- <span class="kbd">Enter</span> detiene la búsqueda sin añadir una nueva línea en el editor.~~
155		-	- Puedes volver a la última búsqueda pulsando <span class="kbd">Ctrl</span>+<span class="kbd">e</span> una segunda vez, inmediatamente después de que empezó con la búsqueda con <span class="kbd">Ctrl</span>+<span class="kbd">e</span> es decir, mientras que el término de búsqueda está vacío.
156		-	~~- Pegar: <span class="kbd">Ctrl</span>+<span class="kbd">V</span> adjuntará el texto del portapapeles al texto de búsqueda actuales (desde lazarus 0.9.27 r19824).~~
	144	+	- Por ejemplo pulsa `e` buscará y resaltará todas las apariciones de 'e'.
	145	+	- Pulsa `t` buscará y resaltará todas las apariciones de 'et' y así sucesivamente.
	146	+	- Puede saltar a la siguiente con `F3` (o `Ctrl`+`e` mientras se busca) y a la previa con `Shift`+`F3`.
	147	+	- `Backspace` elimina el último carácte
	148	+	- `Enter` detiene la búsqueda sin añadir una nueva línea en el editor.
	149	+	- Puedes volver a la última búsqueda pulsando `Ctrl`+`e` una segunda vez, inmediatamente después de que empezó con la búsqueda con `Ctrl`+`e` es decir, mientras que el término de búsqueda está vacío.
	150	+	- Pegar: `Ctrl`+`V` adjuntará el texto del portapapeles al texto de búsqueda actuales (desde lazarus 0.9.27 r19824).
157	151
158	152		### Sugerencia: Búsqueda rápida de un identificador con búsqueda incremental
159	153
160	154		- Mueve el cursor del texto sobre el identificador (no selecciones nada)
161		-	~~- Pulsa <span class="kbd">Ctrl</span>+<span class="kbd">C</span>. En el editor de código fuente se selecciona el identificador y se copia en el portapapeles~~
162		-	~~- Pulsa <span class="kbd">Ctrl</span>+<span class="kbd">E</span> para iniciar la búsqueda incremental~~
163		-	~~- Pulsa <span class="kbd">Ctrl</span>+<span class="kbd">V</span> para buscar el identificador (desde 0.9.27)~~
164		-	~~- Usa <span class="kbd">F3</span> y <span class="kbd">Shift</span>+<span class="kbd">F3</span> para ir rápidamente a siguiente / anterior.~~
	155	+	- Pulsa `Ctrl`+`C`. En el editor de código fuente se selecciona el identificador y se copia en el portapapeles
	156	+	- Pulsa `Ctrl`+`E` para iniciar la búsqueda incremental
	157	+	- Pulsa `Ctrl`+`V` para buscar el identificador (desde 0.9.27)
	158	+	- Usa `F3` y `Shift`+`F3` para ir rápidamente a siguiente / anterior.
165	159		- Usa cualquier tecla (por ejemplo, el cursor hacia la izquierda o la derecha) para finalizar la búsqueda.
166	160
167	161		## Edición sincronizada
168	162
169	163		Edición sincronizada permite editar todas las apariciones de una palabra, al mismo tiempo (sincronizado). Simplemente se edita la palabra en un solo lugar, y mientras escribes, todas las otras apariciones de la palabra también se actualizan.
170	164
171	165		Edición sincronizada funciona en todas las palabras en un área seleccionada:
172	166
173	167		- Selecciona un bloque de texto
174		-	~~- pulsa <span class="kbd">Ctrl</span>+<span class="kbd">J</span> o haz clic en el icono en el margen. (Esto funciono solamente si hay alguna palabra que se repite más de una vez en la selección.~~
175		-	~~- usa la tecla <span class="kbd">tab</span> para seleccionar la palabra que deseas editar (en caso de que varias palabras diferentes se repitan más de una vez)~~
	168	+	- pulsa `Ctrl`+`J` o haz clic en el icono en el margen. (Esto funciono solamente si hay alguna palabra que se repite más de una vez en la selección.
	169	+	- usa la tecla `tab` para seleccionar la palabra que deseas editar (en caso de que varias palabras diferentes se repitan más de una vez)
176	170		- Edita la palabra
177		-	~~- pulsa <span class="kbd">Esc</span> para terminar~~
	171	+	- pulsa `Esc` para terminar
178	172
179	173		Ver un ejemplo animado [[New IDE features since\|aquí]]
180	174
181		-	~~- Nota: <span class="kbd">Ctrl</span>+<span class="kbd">J</span> también se utiliza para editar plantillas. Cambia su significado si hay seleccionado algo de texto.~~
	175	+	- Nota: `Ctrl`+`J` también se utiliza para editar plantillas. Cambia su significado si hay seleccionado algo de texto.
182	176
183	177		## Completar Código
184	178
185		-	Completar código se encuentra en el menú Editar del IDE y su atajo por defecto es <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>. También Aparece en el menú contextual Refactoring -\> Completar código.
	179	+	Completar código se encuentra en el menú Editar del IDE y su atajo por defecto es `Ctrl`+`Shift`+`C`. También Aparece en el menú contextual Refactoring -\> Completar código.
186	180
187		-	Para usuarios de Delphi: En Delphi "code completion" muestra la lista de identificadores en la posición actual del código (<span class="kbd">Ctrl</span>+<span class="kbd">Space</span>). En Lazarus esta función se llama "Completar identificador".
	181	+	Para usuarios de Delphi: En Delphi "code completion" muestra la lista de identificadores en la posición actual del código (`Ctrl`+`Space`). En Lazarus esta función se llama "Completar identificador".
188	182
189	183		Completar código combina varias potentes funciones. Ejemplos:
190	184
191	185		- Completar Clase (Class Completion): completa propiedades, añade cuerpos de métodos, añade variables y métodos privados.
192	186		- Completar procedimiento (Forward Procedure Completion): añade cuerpos de procedimientos.
193	187		- Completar asignación de eventos (Event Assignment Completion): completa la asignación de eventos y añade la definición del método y su cuerpo.
194	188		- Completar declaración de variables (Variable Declaration Completion): añade la declaración de variables locales.
195	189		- Completar llamada a procedimiento (Procedure Call Completion): añade un nuevo procedimiento.
196	190		- Completar procedimiento inverso (Reversed procedure completion): añade la definición de cuerpos para procedimientos y funciones.
197	191		- Completar clase inversa (Reversed class completion): añade declaraciones para cuerpos de métodos.
198	192
199	193		La función que se activa depende de la posición del cursor en el editor de código.
200	194
201	195		### Completar Clase
202	196
203	197		La función más potente de completar código es Completar clase. Escribe la definición de la clase, añade los métodos y las propiedades y Completar clase añadirá los cuerpos de los métodos, los métodos de acceso a las propiedades y variables y las variables privadas.
204	198
205	199		Por ejemplo: crea una clase (utiliza [[IDE Window: Code Templates/es\|Platillas de código]] para ahorrarte trabajo de escritura):
206	200
207	201		``` pascal
208	202		TEjemplo = class(TObject)
209	203		public
210	204		constructor Create;
211	205		destructor Destroy; override;
212	206		end;
213	207		```
214	208
215	209		Pon el cursor en la clase y pulsa Ctrl+Shift+C. Con esto se crean los cuerpos que faltan de los métodos y el cursor se situará dentro del primer cuerpo de método creado, y ya puedes empezar a escribir el código de la clase:
216	210
217	211		``` pascal
218	212		{ TEjemplo }
219	213
220	214		constructor TEjemplo.Create;
221	215		begin
222	216		\|
223	217		end;
224	218
225	219		destructor TEjemplo.Destroy;
226	220		begin
227	221		inherited Destroy;
228	222		end;
229	223		```
230	224
231	225		Nota: El carácter '\\|' representa el cursor.
232	226
233		-	~~Sugerencia: puedes saltar entre la definición y el cuerpo de un método con <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>.~~
	227	+	Sugerencia: puedes saltar entre la definición y el cuerpo de un método con `Ctrl`+`Shift`+`Up`.
234	228
235	229		Cómo se puede ver, el IDE añade la llamada 'inherited Destroy' siempre que el método esté definido con override.
236	230
237	231		Ahora añade un método HacerAlgo:
238	232
239	233		``` pascal
240	234		TEjemplo = class(TObject)
241	235		public
242	236		constructor Create;
243	237		procedure HacerAlgo(i: integer);
244	238		destructor Destroy; override;
245	239		end;
246	240		```
247	241
248		-	~~Ahora se pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> y el IDE añadirá~~
	242	+	Ahora se pulsa `Ctrl`+`Shift`+`C` y el IDE añadirá
249	243
250	244		``` pascal
251	245		procedure TEjemplo.HacerAlgo(i: integer);
252	246		begin
253	247		\|
254	248		end;
255	249		```
256	250
257	251		El método se inserta entre Create y Destroy, igual que en la definición de la clase. De esta forma los cuerpos mantienen el mismo orden lógico que se ha definido. Se puede definir la política de inserción en Entorno -\> Opciones de CodeTools -\> Creación de código.
258	252
259	253		#### Completar Propiedades
260	254
261	255		Añade la propiedad UnEntero:
262	256
263	257		``` pascal
264	258		TEjemplo = class(TObject)
265	259		public
266	260		constructor Create;
267	261		procedure HacerAlgo(i: integer);
268	262		destructor Destroy; override;
269	263		property UnEntero: Integer;
270	264		end;
271	265		```
272	266
273	267		Pulsa Ctrl+Shift+C y obtendrás esto:
274	268
275	269		``` pascal
276	270		procedure TEjemplo.SetUnEntero(const AValue: integer);
277	271		begin
278	272		\|if FUnEntero=AValue then exit;
279	273		FUnEntero:=AValue;
280	274		end;
281	275		```
282	276
283		-	Completar código ha añadido el procedimiento de acceso de escritura a la propiedad (Write) y añadido al mismo el código más común. Ve a la definción de la clase con <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> para ver los cambio realizados en la clase:
	277	+	Completar código ha añadido el procedimiento de acceso de escritura a la propiedad (Write) y añadido al mismo el código más común. Ve a la definción de la clase con `Ctrl`+`Shift`+`Up` para ver los cambio realizados en la clase:
284	278
285	279		``` pascal
286	280		TEjemplo = class(TObject)
287	281		private
288	282		FUnEntero: integer;
289	283		procedure SetUnEntero(const AValue: integer);
290	284		public
291	285		constructor Create;
292	286		procedure HacerAlgo(i: integer);
293	287		destructor Destroy; override;
294	288		property UnEntero: integer read FUnEntero write SetUnEntero;
295	289		end;
296	290		```
297	291
298	292		La propiedad se ha extendido con los modificadores de acceso Read y Write. La clase tiene una nueva sección private con una variable 'FUnEntero' y el procedimiento 'SetUnEntero'. Es habitual en el estilo Delphi añadir 'F' delante del nombre de las variables privadas y 'Set' a los procedimientos. Si no quieres que esto ocurra, cambialo en Entorno -\> Opciones de CodeTools -\> Creación de Código.
299	293
300	294		Crear una propiedad de sólo lectura:
301	295
302	296		``` pascal
303	297		property NombrePropiedad: TipoPropiedad read;
304	298		```
305	299
306	300		Se expandirá a
307	301
308	302		``` pascal
309	303		property NombrePropiedad: TipoPropiedad read FNombrePropiedad;
310	304		```
311	305
312	306		Crear una propiedad de sólo escritura:
313	307
314	308		``` pascal
315	309		property NombrePropiedad: TipoPropiedad write;
316	310		```
317	311
318	312		Se expandirá a
319	313
320	314		``` pascal
321	315		property NombrePropiedad: TipoPropiedad write SetNombrePropiedad;
322	316		```
323	317
324	318		Crear una propiedad de sólo lectura con una función de lectura:
325	319
326	320		``` pascal
327	321		property NombrePropiedad: TipoPropiedad read GetNombrePropiedad;
328	322		```
329	323
330	324		La función GetNombrePropiedad será añadida:
331	325
332	326		``` pascal
333	327		function GetNombrePropiedad: TipoPropiedad;
334	328		```
335	329
336	330		Crear una propiedad con un modificador 'stored':
337	331
338	332		``` pascal
339	333		property NombrePropiedad: TipoPropiedad stored;
340	334		```
341	335
342	336		Se expandirá a
343	337
344	338		``` pascal
345	339		property NombrePropiedad: TipoPropiedad read FNombrePropiedad write SetNombrePropiedad stored NombrePropiedadIsStored;
346	340		```
347	341
348	342		Cómo stored se utiliza para el streaming los modificadores read y write se añaden automáticamente.
349	343
350	344		Sugerencia: Completar identificador también reconoce propiedades incompletas, sugiriendo los nombres por defecto. Por ejemplo:
351	345
352	346		``` pascal
353	347		property NombrePropiedad: TipoPropiedad read \|;
354	348		```
355	349
356	350		Sitúa el cursor un espacio después del 'read' y pulsa Ctrl+Space para invocar Completar identificador. En la lista desplegable se aparecerán la variable 'FNombrePropiedad' y el procedimineto 'GetNombrePropiedad'.
357	351
358	352		### Completar Procedimiento declarado
359	353
360	354		Completar Procedimiento declarado Forward Procedure Completion es parte del Completar código y añade los cuerpos que faltan a los procedimientos declarados. Si se llama cuándo el cursor se encuentra en la declaración de un prodedimiento.
361	355
362	356		Por ejeamplo: Añade un nuevo procedimiento en la sección interface:
363	357
364	358		``` pascal
365	359		procedure HacerAlgo;
366	360		```
367	361
368		-	Sitúa el cursor sobre ella y pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> para completar el código. Se creará lo siguiente en la sección de implementación:
	362	+	Sitúa el cursor sobre ella y pulsa `Ctrl`+`Shift`+`C` para completar el código. Se creará lo siguiente en la sección de implementación:
369	363
370	364		``` pascal
371	365		procedure HacerAlgo;
372	366		begin
373	367		\|
374	368		end;
375	369		```
376	370
377		-	~~Nota: puedes saltar alternativamente entre el cuerpo del procedimiento y su definición pulsando <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>.~~
	371	+	Nota: puedes saltar alternativamente entre el cuerpo del procedimiento y su definición pulsando `Ctrl`+`Shift`+`Up`.
378	372
379	373		El cuerpo del procedimiento se añade antes de los métodos de clase. Si hay más procedimientos declarados en interface el IDE procura mantener el orden de los mismos al crear los cuerpos. Por ejemplo:
380	374
381	375		``` pascal
382	376		procedure Proc1;
383	377		procedure Proc2; // nuevo procedimiento
384	378		procedure Proc3;
385	379		```
386	380
387	381		Si los cuerpos de Proc1 y Proc3 existen, el cuerpo de Proc2 se insertará entre ellos. Este comportamiento se puede configurar en Entorno -\> Opciones de Codetools -\> Creación de código.
388	382
389	383		Varios procedimientos:
390	384
391	385		``` pascal
392	386		procedure Proc1_Viejo; // el cuerpo existe
393	387		procedure Proc2_Nuevo; // el cuerpo No existe
394	388		procedure Proc3_Nuevo; // "
395	389		procedure Proc4_Nuevo; // "
396	390		procedure Proc5_Existente; // el cuerpo existe
397	391		```
398	392
399	393		Completar código añadirá los cuerpos de los tres procedimientos(Proc2_Nuevo, Proc3_Nuevo, Proc4_Nuevo).
400	394
401	395		¿Porqué se llama Forward Procedure Completion?
402	396
403	397		Por que no sólo funciona con procedimientos declarados en la interface , sino que también lo hace para procedimientos con el modificador forward. Las codetools tratan los procedimientos en la interface cómo si tuvieran un modificador forward implícito.
404	398
405	399		### Completar asignación de eventos
406	400
407	401		Completar asignación de eventos (Event Assignment Completion) completa una única asignación de evento (Evento:=\\| sentencia). Se invoca cuándo el cursor está situado justo tras la asignación del evento.
408	402
409	403		Por ejemplo: En un método, el evento FormCreate mismamente, añade la línea 'OnPaint:=':
410	404
411	405		``` pascal
412	406		procedure TForm1.Form1Create(Sender: TObject);
413	407		begin
414	408		OnPaint:=\|
415	409		end;
416	410		```
417	411
418	412		El caracter '\\|' representa el cursor y no hay que escribirlo. Pulsa Ctrl+Shift+C para completar el código. La sentencia se completará con
419	413
420	414		``` pascal
421	415		OnPaint:=@Form1Paint;
422	416		```
423	417
424	418		Un nuevo método Form1Paint se añadirá a la clase TForm1. Y el cursor se situará en el cuerpo de las misma, tras crear su esqueleto:
425	419
426	420		``` pascal
427	421		procedure TForm1.Form1Paint(Sender: TObject);
428	422		begin
429	423		\|
430	424		end;
431	425		```
432	426
433	427		El comportamiento es el mismo que cuándo en el inspector de objetos añadimos código para un evento de un objeto.
434	428
435	429		Nota:Hay que situar el cursor justo tras el operador de asignación ':='. si se sitúa en el identificador (v.gr. OnPaint) se llamará a Completar variable local lo que provoacará un error ya que este ya está definido.
436	430
437	431		Sugerencia: nosotros podemos definir el nombre del método, por ejemplo:
438	432
439	433		``` pascal
440	434		OnPaint:=@ElMetodoParaPintar;
441	435		```
442	436
443		-	~~Para ello hay que situar el cursor sobre el nombre del método antes de llamar a completar código con <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>.~~
	437	+	Para ello hay que situar el cursor sobre el nombre del método antes de llamar a completar código con `Ctrl`+`Shift`+`C`.
444	438
445	439		### Completar Declaración de Variable
446	440
447	441		Completar Declaración de Variable (Variable Declaration Completion) es parte de Completar Código y añade la definición de una variable local para una sentencia identificador:=valor;. Se llama cuándo el cursor está sobre el identificador de la asignación o sobre un parámetro.
448	442
449	443		Por ejemplo:
450	444
451	445		``` pascal
452	446		procedure TForm1.Form1Create(Sender: TObject);
453	447		begin
454	448		i:=3;
455	449		end;
456	450		```
457	451
458		-	~~Sitúa el cursor en la 'i' o justo detrás. Púlsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> para completar el código y se obtiene:~~
	452	+	Sitúa el cursor en la 'i' o justo detrás. Púlsa `Ctrl`+`Shift`+`C` para completar el código y se obtiene:
459	453
460	454		``` pascal
461	455		procedure TForm1.Form1Create(Sender: TObject);
462	456		var
463	457		i: Integer;
464	458		begin
465	459		i:=3;
466	460		end;
467	461		```
468	462
469	463		El proceso comprueba primero si el identificador está definido y al no encontrarlo añade la declaración var i: integer;. El tipo de la variable es tomada del valor del término derecho de la expresión de asignación. Los números, cómo el 3, se crea por defecto por Integer.
470	464
471	465		Otro ejemplo:
472	466
473	467		``` pascal
474	468		type
475	469		TDonde = (Final, Mitad, Principio);
476	470
477	471		procedure TForm1.Form1Create(Sender: TObject);
478	472		var
479	473		a: array[TDonde] of char;
480	474		begin
481	475		for Donde:=Low(a) to High(a) do writeln(a[Donde]);
482	476		end;
483	477		```
484	478
485		-	~~Sitúa el cursor en 'Donde' y pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>, obtendrás:~~
	479	+	Sitúa el cursor en 'Donde' y pulsa `Ctrl`+`Shift`+`C`, obtendrás:
486	480
487	481		``` pascal
488	482		procedure TForm1.Form1Create(Sender: TObject);
489	483		var
490	484		a: array[TDonde] of char;
491	485		Donde: TDonde;
492	486		begin
493	487		for Donde:=Low(a) to High(a) do writeln(a[Donde]);
494	488		end;
495	489		```
496	490
497	491		Desde la versión 0.9.11 Lazarus también completa parámetros. Por ejemplo
498	492
499	493		``` pascal
500	494		procedure TForm1.FormPaint(Sender: TObject);
501	495		begin
502	496		with Canvas do begin
503	497		Line(x1,y1,x2,y2);
504	498		end;
505	499		end;
506	500		```
507	501
508		-	~~Sitúa el cursor en 'x1' y pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>, obtendrás:~~
	502	+	Sitúa el cursor en 'x1' y pulsa `Ctrl`+`Shift`+`C`, obtendrás:
509	503
510	504		``` pascal
511	505		procedure TForm1.FormPaint(Sender: TObject);
512	506		var
513	507		x1: integer;
514	508		begin
515	509		with Canvas do begin
516	510		Line(x1,y1,x2,y2);
517	511		end;
518	512		end;
519	513		```
520	514
521	515		### Completar Llamada a procedimiento
522	516
523	517		Nota de traductor: lo que sigue no funciona, si lo intentamos no hace nada.
524	518
525	519		Completar código creará un nuevo procedimiento desde la orden de invocación.
526	520
527	521		Supongamos que acabas de escribir la orden HacerAlgo(Ancho);
528	522
529	523		``` pascal
530	524		procedure UnProcedimiento;
531	525		var
532	526		Ancho: integer;
533	527		begin
534	528		Ancho:=3;
535	529		HacerAlgo(Ancho);
536	530		end;
537	531		```
538	532
539		-	~~Coloca el cursor sobre el identificador "HacerAlgo" y pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> para obtener:~~
	533	+	Coloca el cursor sobre el identificador "HacerAlgo" y pulsa `Ctrl`+`Shift`+`C` para obtener:
540	534
541	535		``` pascal
542	536		procedure HacerAlgo(aWidth: LongInt);
543	537		begin
544	538
545	539		end;
546	540
547	541		procedure UnProcedimiento;
548	542		var
549	543		Width: integer;
550	544		begin
551	545		Width:=3;
552	546		HacerAlgo(Width);
553	547		end;
554	548		```
555	549
556	550		### Completar Clase inversa
557	551
558	552		"Completar Clase inversa" es otra función de Completar ya Código que añade la declaración de un método para el cuerpo de funcion o procedimiento en que esté situado el cursor cuando se invoca; si la declaración existie dará un mensaje de error: Ya fue definido el identificador ....
559	553
560	554		Esta función está disponible desde la versión 0.9.21 de Lazarus.
561	555
562	556		Por ejemplo:
563	557
564	558		``` pascal
565	559		procedure TForm1.HacerAlgo(Emisor: TObject);
566	560		begin
567	561		end;
568	562		```
569	563
570		-	El método HacerAlgo no está declarado en TForm1. Pulsar <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> y el IDE añadirá "procedure HacerAlgo(Emisor: TObject);" en la definición de la clase TForm1.
	564	+	El método HacerAlgo no está declarado en TForm1. Pulsar `Ctrl`+`Shift`+`C` y el IDE añadirá "procedure HacerAlgo(Emisor: TObject);" en la definición de la clase TForm1.
571	565
572	566		Para usuarios de Delphi: Completar clase funciona en Lazarus siempre en un único sentido: de interface a implementation o viceversa. Delphi invoca siempre los dos sentidos. La forma de Delphi tiene la desventaja de que por un error tipográfico podemos crear inadvertidamente un procedimineto nuevo.
573	567
574	568		### Comentarios y Completar código
575	569
576	570		Completar código procura mantener los comentarios donde corresponde.
577	571
578	572		Por ejemplo:
579	573
580	574		``` pascal
581	575		FLista: TList; // lista de TComponent
582	576		FEntero: integer;
583	577		```
584	578
585	579		Cuándo se inserta una nueva variable entre FLista y FEntero, el comentario permanece en la línea de FLista. Esto también es verdad para
586	580
587	581		``` pascal
588	582		FLista: TList; { lista de TComponent
589	583		Este es un comentario de varias líneas, comienza
590	584		en la línea FLista, a la que la utilidad considera
591	585		que pertenece y no romperá esta ligazón.
592	586		El código se inserta después del comentario.}
593	587		FEntero: integer;
594	588		```
595	589
596	590		Si el comentario comienza en la línea siguiente, será tratado como perteneciente al código que le sigue. Por ejemplo:
597	591
598	592		``` pascal
599	593		FLista: TList; // lista de TComponent
600	594		{ Este comentario está ligado a la sentencia precedente.
601	595		El nuevo código será insertado delante del comentario
602	596		a continuación del comentario de la línea de FLista. }
603	597		FEntero: integer;
604	598		```
605	599
606	600		## Refactorización (Refactoring)
607	601
608	602		### Invertir Asignaciones
609	603
610	604		Invertir Asignaciones toma las instrucciones de asignación señaladas e invierte las mismas para ese código. Con esta utilidad es fácil transformar código de guardar en código de cargar, o a la inversa.
611	605
612	606		Ejemplo:\
613	607
614	608		``` pascal
615	609		procedure HacerAlgo;
616	610		begin
617	611		AValueUnoStudio := BValorUno;
618	612		AValorDos := BValorDos;
619	613		AValorTres := BValorTres;
620	614		end;
621	615		```
622	616
623	617		Selecciona las líneas con las asignaciones (entre begin y end ) e invoca Invert Assignments. Todas las ordenes de asignación se invertirán y el código se formateará automáticamente; el resultado será este:
624	618
625	619		``` pascal
626	620		procedure HacerAlgo;
627	621		begin
628	622		BValorUno := AValueUnoStudio;
629	623		BValorDos := AValorDos;
630	624		BValorTres := AValorTres;
631	625		end;
632	626		```
633	627
634	628		### Encerrar Selección
635	629
636	630		Selecciona un blouqe de texto e invócala, con el menú contextual (Refactoring -\> Encerrar Selección), por ejemplo. En el [[:File:Lazarus IDE Encerrar Seleccion.png\|diálogo que aparece]] puedes seleccionar en que estructura se encerrará el código seleccionado, try..finally o cualquier otro tipo de bloque de los posibles.
637	631
638	632		### Renombrar Identificador
639	633
640	634		Sitúa el cursor sobre un identificador y llámalo. Aparece un [[:File:Lazarus IDE Buscar Referencias Identificador.png\|diálogo]] en el que podemos configurar el ámbito de la búsqueda y el nuevo nombre.
641	635
642	636		- Se renombra´na todas las ocurrencias que utilicen esta declaración. No lo hará con otras declaraciones con el mismo nombre.
643	637		- Primero comprueba los posibles conflictos de nombre.
644	638		- Límites: Únicamente funciona con código pascal, no cambia el nombre a archivos y no modifica archivos lfm/lrs ni archivos lazdoc.
645	639
646	640		### Buscar referencias a identificador
647	641
648	642		Sitúa el cursor sobre un identificador y llámalo (menú Buscar -\> Buscar referencias a identificador...), aparece un [[:File:Lazarus IDE Buscar Referencias Identificador.png\|diálogo]], donde se puede configurar el ámbito de búsqueda. El IDE busca todas las ocurrencias y sólo aquellas que utilizan esta declaración. Esto quiere decir que no muestra otras declaraciones distintas con el mismo nombre.
649	643
650	644		### Mostrar métodos abstractos
651	645
652	646		Esta utilidad lista y crea el esquema de métodos virtuales y abstractos que necesitan ser implementados.
653	647
654	648		Sitúa el cursor en la declaración de la clase y llámalo. Si hay métodos abstractos que implemetar un diálogo aparece con su lista. Selecciona el método para implementar y el IDE creará el esqueleto del mismo.
655	649
656	650		### Extraer Procedimientos
657	651
658	652		Ver [[IDE Window: Extract Procedure/es\|Extraer Procedimientos]]
659	653
660	654		## Buscar Declaración
661	655
662	656		Coloca el cursor en un identificador y utiliza Buscar declaración del menú contextual, se buscará la definición del mismo y se abrirá el archivo que la contiene, situándose el cursor sobre ella. Si el cursor ya se encuentra ya en una declaración se saltará a la declaración anterior del mismo identificador. Esto permite encontrar sobrescrituras y redefiniciones
663	657
664		-	Cada búsqueda crea un punto de salto (Jump Point). Esto permite saltar entre la definición hallada y el punto donde estábamos antes, menú principal: Buscar -\> Saltar atrás o <span class="kbd">Ctrl</span>+<span class="kbd">H</span>.
	658	+	Cada búsqueda crea un punto de salto (Jump Point). Esto permite saltar entre la definición hallada y el punto donde estábamos antes, menú principal: Buscar -\> Saltar atrás o `Ctrl`+`H`.
665	659
666	660		Existen algunas diferencias con Delphi: Las utilidades de completar código siguen las convenciones de pascal en vez de utilizar la salida del compilador. El compilador devuelve el tipo final. Las utilidades de completar código miran las fuentes y siguen todos los pasos intermedios. Por ejemplo:
667	661
668	662		La propiedad Visible está definida en primer lugar en TControl (controls.pp), está redefinida en TCustomForm y por último en TForm.
669	663
670	664		Llamando a buscar declaración para Visible se saltará primero a la definición de Visible en TForm. Si se llama de nuevo se saltará a Visible en TCustomForm y si lo hacemos otra vez saltará a Visible en TControl.
671	665
672	666		Esto también ocurre para tipos cómo TColor. Para el compilador es un simple longint. Pero en los fuentes está definido cómo
673	667
674	668		``` pascal
675	669		TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
676	670		TColor = TGraphicsColor;
677	671		```
678	672
679	673		Y ocurre lo mismo con las clases definidas con antelación (forward defined classes): Por ejemplo en TControl, está esta variable privada
680	674
681	675		``` pascal
682	676		FHostDockSite: TWinControl;
683	677		```
684	678
685	679		Buscar declaración sobre TWinControl saltará a la definición previa (forward defined classe)
686	680
687	681		``` pascal
688	682		TWinControl = class;
689	683		```
690	684
691	685		Y haciéndolo de nuevo saltará a la implementación real
692	686
693	687		``` pascal
694	688		TWinControl = class(TControl)
695	689		```
696	690
697	691		De esta forma se puede seguir hasta el final la declaración de cada identificador y ver cada sobrecarga o redefinición del mismo.
698	692
699		-	Sugerencia: Puedes regresar al punto anterior al salto con <span class="kbd">Ctrl</span>+<span class="kbd">H</span>.
	693	+	Sugerencia: Puedes regresar al punto anterior al salto con `Ctrl`+`H`.
700	694
701	695		## Completar Identificador
702	696
703		-	~~Completar Identificador se llama con <span class="kbd">Ctrl</span>+<span class="kbd">Space</span>. Se mostrarán todos los identifiacdores en el ámbito. Por ejemplo:~~
	697	+	Completar Identificador se llama con `Ctrl`+`Space`. Se mostrarán todos los identifiacdores en el ámbito. Por ejemplo:
704	698
705	699		``` pascal
706	700		procedure TForm1.FormCreate(Sender: TObject);
707	701		begin
708	702		\|
709	703		end;
710	704		```
711	705
712		-	Sitúa el cursor entre begin y end y pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Space</span>. La utilidad e código del IDE analizará todo el código del ámbito y presentará una lista con todos los identificadores encontrados. El IDE guarda los resultados, así que una llamada posterior será mucho más rápida.
	706	+	Sitúa el cursor entre begin y end y pulsa `Ctrl`+`Space`. La utilidad e código del IDE analizará todo el código del ámbito y presentará una lista con todos los identificadores encontrados. El IDE guarda los resultados, así que una llamada posterior será mucho más rápida.
713	707
714	708		Nota para usuarios Delphi: En Delphi esto se denomina Completar Código.
715	709
716	710		Muchos identificadores cómo 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' están creados dentro del compilador y no están definidos en código alguno. Completar identificador hace lo propio. Si notas la falta de alguno informa de ello en el seguimiento de errores (bug tracker)
717	711
718		-	Completar identificador no completa palabras del lenguaje. No puede ser utilizado para completar proc a procedura. Para hacer esto utiliza <span class="kbd">Ctrl</span>+<span class="kbd">W</span> Completar palabra y no <span class="kbd">Ctrl</span>+<span class="kbd">J</span> Plantillas de código.
	712	+	Completar identificador no completa palabras del lenguaje. No puede ser utilizado para completar proc a procedura. Para hacer esto utiliza `Ctrl`+`W` Completar palabra y no `Ctrl`+`J` Plantillas de código.
719	713
720	714		Completar identificador muestra incluso los identificadores que no son compatibles.
721	715
722	716		### Prefijos
723	717
724	718		Cuándo activamos Completar identificador en una palabra, las letras a la derecha del cursor son consideradas un prefijo y la lista de sugerencias sólo mostrará los identificadores que comienzan por ellas. Por ejemplo:
725	719
726	720		``` pascal
727	721		procedure TForm1.FormCreate(Sender: TObject);
728	722		begin
729	723		Ca\|ption
730	724		end;
731	725		```
732	726
733	727		Sólo se mostrarán los identificadores que comienzan por 'Ca'.
734	728
735	729		### Teclas
736	730
737	731		- Letra o numero: añade el carácter al código del editor y al prefijo. La lista se actualiza.
738		-	~~- Borrar hacia atrás (<span class="kbd">Backspace</span>): elimina el carácter código del editor y al prefijo. La lista se actualiza.~~
739		-	~~- <span class="kbd">Intro</span> / <span class="kbd">Enter</span>: reemplaza la palabra completa bajo el cursor con el identificador seleccionado y cierra la lista.~~
740		-	~~- <span class="kbd">Shift</span>+<span class="kbd">Enter</span>: cómo <span class="kbd">Enter</span>, pero reemplaza únicamente el prefijo (la parte izquierda) de la palabra bajo el cursor.~~
741		-	~~- <span class="kbd">Up</span> / <span class="kbd">Down</span>: mueve la selección de identificador en la lista.~~
742		-	~~- <span class="kbd">Escape</span>: cierra la lista sin realizar cambios.~~
743		-	- <span class="kbd">Tab</span>: completa el prefijo a la siguiente selección. Por ejrmplo: El prefijo actual es 'But' y la lista sólo muestra 'Button1' y 'Button1Click'. Púlsando <span class="kbd">Tab</span> el prefijo se completa a 'Button1'.
	732	+	- Borrar hacia atrás (`Backspace`): elimina el carácter código del editor y al prefijo. La lista se actualiza.
	733	+	- `Intro` / `Enter`: reemplaza la palabra completa bajo el cursor con el identificador seleccionado y cierra la lista.
	734	+	- `Shift`+`Enter`: cómo `Enter`, pero reemplaza únicamente el prefijo (la parte izquierda) de la palabra bajo el cursor.
	735	+	- `Up` / `Down`: mueve la selección de identificador en la lista.
	736	+	- `Escape`: cierra la lista sin realizar cambios.
	737	+	- `Tab`: completa el prefijo a la siguiente selección. Por ejrmplo: El prefijo actual es 'But' y la lista sólo muestra 'Button1' y 'Button1Click'. Púlsando `Tab` el prefijo se completa a 'Button1'.
744	738		- Otras teclas: realizan su cometido normal y cierran la lista si es necesario.
745	739
746	740		### Métodos
747	741
748	742		Cuándo el cursor se encuentra en una definición de clase y se utiliza Completar identificador aparecerán en la lista los métodos de la clase padre con sus parámetros, e incluirá el override. Por ejemplo:
749	743
750	744		``` pascal
751	745		TMainForm = class(TForm)
752	746		protected
753	747		mous\|
754	748		end;
755	749		```
756	750
757	751		Completando con MouseDown obtendremos esto:
758	752
759	753		``` pascal
760	754		TMainForm = class(TForm)
761	755		protected
762	756		procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
763	757		Y: Integer); override;
764	758		end;
765	759		```
766	760
767	761		### Propiedades
768	762
769	763		``` pascal
770	764		property MiEntero: integer read \|;
771	765		```
772	766
773	767		Completar identificador mostrará en la lista *FMiEntero'' y*GetMiEntero''.
774	768
775	769		``` pascal
776	770		property MiEntero: integer write \|;
777	771		```
778	772
779	773		Completar identificador mostrará en la lista *FMiEntero'' y*SetMiEntero''.
780	774
781	775		### Sección Uses / nombres de unidad
782	776
783	777		En la sección Uses la función Completar identificador muestra los nombres de todos los archivos de todas las unidades en la ruta de búsqueda. Se mostraán en minúsculas (v.gr. avl_tree), ya que la mayoría tienen de unidades tienen el nombre en minúsculas. Al completar pondrá el nombre verdadero de la unidad (v.gr. AVL_Tree).
784	778
785	779		### Sentencias
786	780
787	781		``` pascal
788	782		procedure TMainForm.Button1Click(Sender: TObject);
789	783		begin
790	784		ModalRe\|;
791	785		end;
792	786		```
793	787
794	788		se convierte en:
795	789
796	790		``` pascal
797	791		procedure TMainForm.Button1Click(Sender: TObject);
798	792		begin
799	793		ModalResult:=\|;
800	794		end;
801	795		```
802	796
803	797		## Completar palabra
804	798
805		-	Completar palabra se invoca con <span class="kbd">Ctlr</span>+<span class="kbd">W</span>. Muestra una lista con todas las palabras y todos los archivos abiertos en ese momento en el editor. Por lo demás se comporta igual que Completar identificador.
	799	+	Completar palabra se invoca con `Ctlr`+`W`. Muestra una lista con todas las palabras y todos los archivos abiertos en ese momento en el editor. Por lo demás se comporta igual que Completar identificador.
806	800
807	801		## Ir a directiva de inclusión
808	802
809	803		Ir a directiva de inclusión en el menú Buscar del IDE salta a la sentencia {\$I filename} en que el fichero actual de inclusión es invocado.
810	804
811	805		## Publicar Proyecto
812	806
813	807		En el menú Proyecto -\> Publicar proyecto.... Crea una copia del proyecto completo. Si quieres enviar tú código y sus opciones de compilación a alguien esto te ayudará.
814	808
815	809		Un directorio normal de proyecto contiene mucha información, pero no es necesario hacerla pública toda:
816	810
817	811		El archivo .lpi contiene información de la sesión (cómo la posición del cursor y los marcadores de unidades cerradas) y el directorio contine archivos .ppu, .o y el ejecutable.
818	812
819	813		Elige un directorio vacío donde publicar el proyecto, ya que si existen archivos en el directorio elegido, se eliminarán al publicar el proyecto. (Un diálogo advierte sobre esto).
820	814
821	815		Para crear un archivo .lpi únicamente con la información básica y con los fuentes, junto con los directorios necesarios utiliza Publicar Proyecto.
822	816
823	817		Nota: Desde la versión 0.9.13 existe una nueva Opciones de proyecto [[:File:Lazarus IDE Opciones Proyecto Sesion.png\|Sesión]] que permite guardar la información de sesión en un archivo distinto del .lpi normal. Este nuevo archivo tiene extensión .lps y contiene únicamente la información de la sesión, para dejar el .lpi más legible.
824	818
825	819		En el [[:File:Lazarus IDE Publicar Proyecto.png\|diálogo]] puedes configurar el filtro de archivos a incluir y excluir y con Command after puedes procesar la salida para comprimir esta en un archivo.
826	820
827	821		## Sugerencias desde comentarios
828	822
829	823		En varios lugares el IDE muestra sugerencias de un identificador. Por ejemplo cuando mueves el ratón sobre un identificador en el editor de código fuente y esperas unos segundos.
830	824
831	825		Cuando el IDE muestra algunas pistas para un identificador busca la declaración y la de todos sus ancestros y busca comentarios y archivos fpdoc. Hay muchos estilos de codificación y muchos estilos de comentario. A fin de apoyar muchos de los estilos de comentario común el IDE utiliza la heurística siguiente
832	826
833	827		### Comentarios mostrados en la sugerencia
834	828
835	829		Comentarios precediendo a una declaración, sin línea vacía y que no empiezan con el signo \<:
836	830
837	831		``` pascal
838	832		var
839	833		{comentario}
840	834		Identifier: integer;
841	835		```
842	836
843	837		Comentarios con el signo \< pertenecen al identificador precedente.
844	838
845	839		Comentarios detrás de un identificador en la misma línea:
846	840
847	841		``` pascal
848	842		var
849	843		identifier, // comentario
850	844		other,
851	845		```
852	846
853	847		Comentarios tras la definición en la misma línea:
854	848
855	849		``` pascal
856	850		var
857	851		identifier:
858	852		char; // comentario
859	853		```
860	854
861	855		Un ejemplo para el signo \<:
862	856
863	857		``` pascal
864	858		const
865	859		a = 1;
866	860		//< comentario para a
867	861		b = 2;
868	862		// comentario para c
869	863		c = 3;
870	864		```
871	865
872	866		Los tres tipos de comentarios son compatibles:
873	867
874	868		``` pascal
875	869		{Comentario}(Comentario)//Comentario
876	870		c = 1;
877	871		```
878	872
879	873		Los comentarios que empiezan con \$ y % son ignorados.
880	874
881	875		### Comentarios que no se muestra en la sugerencia
882	876
883	877		Comentarios precedentes separados por una línea en blanco se tratan como no específicas del identificador siguiente. Por ejemplo el comentario de la cabecera de clase siguiente no se muestra en la sugerencia:
884	878
885	879		``` pascal
886	880		type
887	881		{ TMyClass }
888	882
889	883		TMyClass = class
890	884		```
891	885
892	886		Los comentarios de cabecera de la clase se crean en la finalización de clases. Puede desactivar esta opción en Entorno / Opciones / Codetools / Terminado de Clases / Comentario de cabecera para la clase. Si desea mostrar el comentario de cabecera en la sugerencia, basta con eliminar la línea vacía.
893	887
894	888		El siguiente comentario será mostrado para GL_TRUE, pero no para GL_FALSE:
895	889
896	890		``` pascal
897	891		// Boolean
898	892		GL_TRUE = 1;
899	893		GL_FALSE = 0;
900	894		```
901	895
902	896		## Contribuciones y cambios
903	897
904	898		Esta página ha sido convertida desde la [versión de epikwiki](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools).
905	899
906	900		- Creación de la página y plantilla original - 4/6/2004 VlxAdmin
907	901		- Nuevo contenido inicial - 4/10/2004 MattiasG
908	902		- Pequeños retoque sobre formato - 4/11/2004 VlxAdmin
909	903		- Adición de la Tabla resumen de los atajos de las IdeTools - 12 July 2004 User:Kirkpatc
910	904		- Versión en castellano (español) iskraelectrica (jldc) / junio-julio de 2008.
911	905
912	906		---
913	907		From the Free Pascal wiki, page "Lazarus IDE Tools/es", as it stood on 2022-01-20 after a change by Kai Burghardt, 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).
914	908		Category: Castellano
915	909		Category: Español

Back to history