Sign in Join
Wiki copytemporary

Lazarus IDE Tools/es: what changed

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

Title: Lazarus IDE Tools/es

OldNewLine
1+## Descripción general
2+
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+
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+
7+## Tabla resumen de los atajos
8+
9+| | |
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> |
20+
21+## Salto a Procedimiento
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>.
24+
25+   Por ejemplo:
26+
27+``` pascal
28+ interface
29+ procedure HacerAlgo; // declaración del procedimiento
30+ //...
31+ implementation
32+ //...
33+ procedure HacerAlgo; // Cuerpo del procedimiento
34+ begin
35+ //...
36+ end;
37+```
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*.
40+
41+   Esto funciona con procedimientos y funciones, sean o no miembros de una clase.
42+
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+
45+   Por ejemplo una función con diferente lista de parámetros:
46+
47+``` pascal
48+ interface
49+
50+ function HacerAlgo(p: char); // declaración de la función
51+
52+ implementation
53+
54+ function HacerAlgo(p: string); // cuerpo de la función
55+ begin
56+ end;
57+```
58+
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+
61+   Por ejemplo:\
62+   Remombramos 'HacerAlgo' a 'Hazlo':
63+
64+``` pascal
65+ interface
66+
67+ procedure Hazlo; // declaración del procedimiento
68+
69+ implementation
70+
71+ procedure HacerAlgo; // Cuerpo del procedimiento
72+ begin
73+ end;
74+```
75+
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+
78+## Archivos de inclusión
79+
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+
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+
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+
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+
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+
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+
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+
94+## Plantillas de código
95+
96+   Las *Plantillas de código* permiten convertir un identificador en un texto o en un fragmento de código.
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...*.
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
101+
102+``` pascal
103+ TClass = class(TBase)
104+ private
105+
106+ public
107+ constructor Create;
108+ destructor Destroy; override;
109+ end;
110+```
111+
112+además el cursor de posicionará en 'TClass'.
113+
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+
116+  La plantilla que más tiempo nos ahorrará es 'b'+<span class="kbd">Ctrl</span>+<span class="kbd">J</span> para begin..end.
117+
118+## Sugerencia de Parámetros
119+
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+
122+   Por ejemplo:
123+
124+``` pascal
125+ Canvas.FillRect(|);
126+```
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*.
129+
130+<figure>
131+<img src="Parameterhints1.png" title="Parameterhints1.png" />
132+<figcaption>Parameterhints1.png</figcaption>
133+</figure>
134+
135+   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+
137+<figure>
138+<img src="Parameterhints2.png" title="Parameterhints2.png" />
139+<figcaption>Parameterhints2.png</figcaption>
140+</figure>
141+
142+   Consejo: Utiliza Completar Declaración de Variable para declarar las variables.
143+
144+   Nota: El nombre del atajo es "Show code context" (Mostrar Contexto del Código).
145+
146+## Búsqueda incremental
147+
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>.
149+
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).
157+
158+### Sugerencia: Búsqueda rápida de un identificador con búsqueda incremental
159+
160+- 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.
165+- Usa cualquier tecla (por ejemplo, el cursor hacia la izquierda o la derecha) para finalizar la búsqueda.
166+
167+## Edición sincronizada
168+
169+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+
171+Edición sincronizada funciona en todas las palabras en un área seleccionada:
172+
173+- 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)
176+- Edita la palabra
177+- pulsa <span class="kbd">Esc</span> para terminar
178+
179+Ver un ejemplo animado [[New IDE features since|aquí]]
180+
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.
182+
183+## Completar Código
184+
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.
186+
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".
188+
189+   Completar código combina varias potentes funciones. Ejemplos:
190+
191+- Completar Clase (*Class Completion*): completa propiedades, añade cuerpos de métodos, añade variables y métodos privados.
192+- Completar procedimiento (*Forward Procedure Completion*): añade cuerpos de procedimientos.
193+- 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+- Completar declaración de variables (*Variable Declaration Completion*): añade la declaración de variables locales.
195+- Completar llamada a procedimiento (*Procedure Call Completion*): añade un nuevo procedimiento.
196+- Completar procedimiento inverso (*Reversed procedure completion*): añade la definición de cuerpos para procedimientos y funciones.
197+- Completar clase inversa (*Reversed class completion*): añade declaraciones para cuerpos de métodos.
198+
199+   La función que se activa depende de la posición del cursor en el editor de código.
200+
201+### Completar Clase
202+
203+   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+
205+   Por ejemplo: crea una clase (utiliza [[IDE Window: Code Templates/es|Platillas de código]] para ahorrarte trabajo de escritura):
206+
207+``` pascal
208+ TEjemplo = class(TObject)
209+ public
210+ constructor Create;
211+ destructor Destroy; override;
212+ end;
213+```
214+
215+   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+
217+``` pascal
218+ { TEjemplo }
219+
220+ constructor TEjemplo.Create;
221+ begin
222+ |
223+ end;
224+
225+ destructor TEjemplo.Destroy;
226+ begin
227+ inherited Destroy;
228+ end;
229+```
230+
231+   Nota: El carácter '\|' representa el cursor.
232+
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>.
234+
235+   Cómo se puede ver, el IDE añade la llamada 'inherited Destroy' siempre que el método esté definido con *override*.
236+
237+   Ahora añade un método HacerAlgo:
238+
239+``` pascal
240+ TEjemplo = class(TObject)
241+ public
242+ constructor Create;
243+ procedure HacerAlgo(i: integer);
244+ destructor Destroy; override;
245+ end;
246+```
247+
248+   Ahora se pulsa <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> y el IDE añadirá
249+
250+``` pascal
251+ procedure TEjemplo.HacerAlgo(i: integer);
252+ begin
253+ |
254+ end;
255+```
256+
257+   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+
259+#### Completar Propiedades
260+
261+   Añade la propiedad UnEntero:
262+
263+``` pascal
264+ TEjemplo = class(TObject)
265+ public
266+ constructor Create;
267+ procedure HacerAlgo(i: integer);
268+ destructor Destroy; override;
269+ property UnEntero: Integer;
270+ end;
271+```
272+
273+   Pulsa Ctrl+Shift+C y obtendrás esto:
274+
275+``` pascal
276+ procedure TEjemplo.SetUnEntero(const AValue: integer);
277+ begin
278+ |if FUnEntero=AValue then exit;
279+ FUnEntero:=AValue;
280+ end;
281+```
282+
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:
284+
285+``` pascal
286+ TEjemplo = class(TObject)
287+ private
288+ FUnEntero: integer;
289+ procedure SetUnEntero(const AValue: integer);
290+ public
291+ constructor Create;
292+ procedure HacerAlgo(i: integer);
293+ destructor Destroy; override;
294+ property UnEntero: integer read FUnEntero write SetUnEntero;
295+ end;
296+```
297+
298+    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+
300+   Crear una propiedad de sólo lectura:
301+
302+``` pascal
303+ property NombrePropiedad: TipoPropiedad read;
304+```
305+
306+   Se expandirá a
307+
308+``` pascal
309+ property NombrePropiedad: TipoPropiedad read FNombrePropiedad;
310+```
311+
312+   Crear una propiedad de sólo escritura:
313+
314+``` pascal
315+ property NombrePropiedad: TipoPropiedad write;
316+```
317+
318+   Se expandirá a
319+
320+``` pascal
321+ property NombrePropiedad: TipoPropiedad write SetNombrePropiedad;
322+```
323+
324+   Crear una propiedad de sólo lectura con una función de lectura:
325+
326+``` pascal
327+ property NombrePropiedad: TipoPropiedad read GetNombrePropiedad;
328+```
329+
330+   La función GetNombrePropiedad será añadida:
331+
332+``` pascal
333+ function GetNombrePropiedad: TipoPropiedad;
334+```
335+
336+   Crear una propiedad con un modificador 'stored':
337+
338+``` pascal
339+ property NombrePropiedad: TipoPropiedad stored;
340+```
341+
342+   Se expandirá a
343+
344+``` pascal
345+ property NombrePropiedad: TipoPropiedad read FNombrePropiedad write SetNombrePropiedad stored NombrePropiedadIsStored;
346+```
347+
348+   Cómo *stored* se utiliza para el *streaming* los modificadores *read* y *write* se añaden automáticamente.
349+
350+   Sugerencia: Completar identificador también reconoce propiedades incompletas, sugiriendo los nombres por defecto. Por ejemplo:
351+
352+``` pascal
353+ property NombrePropiedad: TipoPropiedad read |;
354+```
355+
356+   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+
358+### Completar Procedimiento declarado
359+
360+   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+
362+   Por ejeamplo:    Añade un nuevo procedimiento en la sección *interface*:
363+
364+``` pascal
365+ procedure HacerAlgo;
366+```
367+
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:
369+
370+``` pascal
371+ procedure HacerAlgo;
372+ begin
373+ |
374+ end;
375+```
376+
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>.
378+
379+   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+
381+``` pascal
382+ procedure Proc1;
383+ procedure Proc2; // nuevo procedimiento
384+ procedure Proc3;
385+```
386+
387+   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+
389+   Varios procedimientos:
390+
391+``` pascal
392+ procedure Proc1_Viejo; // el cuerpo existe
393+ procedure Proc2_Nuevo; // el cuerpo No existe
394+ procedure Proc3_Nuevo; // "
395+ procedure Proc4_Nuevo; // "
396+ procedure Proc5_Existente; // el cuerpo existe
397+```
398+
399+   Completar código añadirá los cuerpos de los tres procedimientos(Proc2_Nuevo, Proc3_Nuevo, Proc4_Nuevo).
400+
401+   ¿Porqué se llama *Forward Procedure Completion*?
402+
403+   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+
405+### Completar asignación de eventos
406+
407+   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+
409+   Por ejemplo:    En un método, el evento FormCreate mismamente, añade la línea 'OnPaint:=':
410+
411+``` pascal
412+ procedure TForm1.Form1Create(Sender: TObject);
413+ begin
414+ OnPaint:=|
415+ end;
416+```
417+
418+   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+
420+``` pascal
421+ OnPaint:=@Form1Paint;
422+```
423+
424+   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+
426+``` pascal
427+ procedure TForm1.Form1Paint(Sender: TObject);
428+ begin
429+ |
430+ end;
431+```
432+
433+   El comportamiento es el mismo que cuándo en el inspector de objetos añadimos código para un evento de un objeto.
434+
435+   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+
437+   Sugerencia: nosotros podemos definir el nombre del método, por ejemplo:
438+
439+``` pascal
440+ OnPaint:=@ElMetodoParaPintar;
441+```
442+
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>.
444+
445+### Completar Declaración de Variable
446+
447+   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+
449+   Por ejemplo:
450+
451+``` pascal
452+ procedure TForm1.Form1Create(Sender: TObject);
453+ begin
454+ i:=3;
455+ end;
456+```
457+
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:
459+
460+``` pascal
461+ procedure TForm1.Form1Create(Sender: TObject);
462+ var
463+ i: Integer;
464+ begin
465+ i:=3;
466+ end;
467+```
468+
469+   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+
471+   Otro ejemplo:
472+
473+``` pascal
474+ type
475+ TDonde = (Final, Mitad, Principio);
476+
477+ procedure TForm1.Form1Create(Sender: TObject);
478+ var
479+ a: array[TDonde] of char;
480+ begin
481+ for Donde:=Low(a) to High(a) do writeln(a[Donde]);
482+ end;
483+```
484+
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:
486+
487+``` pascal
488+ procedure TForm1.Form1Create(Sender: TObject);
489+ var
490+ a: array[TDonde] of char;
491+ Donde: TDonde;
492+ begin
493+ for Donde:=Low(a) to High(a) do writeln(a[Donde]);
494+ end;
495+```
496+
497+   Desde la versión 0.9.11 Lazarus también completa parámetros. Por ejemplo
498+
499+``` pascal
500+ procedure TForm1.FormPaint(Sender: TObject);
501+ begin
502+ with Canvas do begin
503+ Line(x1,y1,x2,y2);
504+ end;
505+ end;
506+```
507+
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:
509+
510+``` pascal
511+ procedure TForm1.FormPaint(Sender: TObject);
512+ var
513+ x1: integer;
514+ begin
515+ with Canvas do begin
516+ Line(x1,y1,x2,y2);
517+ end;
518+ end;
519+```
520+
521+### Completar Llamada a procedimiento
522+
523+   **Nota de traductor:** lo que sigue no funciona, si lo intentamos no hace nada.
524+
525+   Completar código creará un nuevo procedimiento desde la orden de invocación.
526+
527+   Supongamos que acabas de escribir la orden *HacerAlgo(Ancho);*
528+
529+``` pascal
530+ procedure UnProcedimiento;
531+ var
532+ Ancho: integer;
533+ begin
534+ Ancho:=3;
535+ HacerAlgo(Ancho);
536+ end;
537+```
538+
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:
540+
541+``` pascal
542+ procedure HacerAlgo(aWidth: LongInt);
543+ begin
544+
545+ end;
546+
547+ procedure UnProcedimiento;
548+ var
549+ Width: integer;
550+ begin
551+ Width:=3;
552+ HacerAlgo(Width);
553+ end;
554+```
555+
556+### Completar Clase inversa
557+
558+   "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+
560+   Esta función está disponible desde la versión 0.9.21 de Lazarus.
561+
562+   Por ejemplo:
563+
564+``` pascal
565+ procedure TForm1.HacerAlgo(Emisor: TObject);
566+ begin
567+ end;
568+```
569+
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.
571+
572+   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+
574+### Comentarios y *Completar código*
575+
576+   *Completar código* procura mantener los comentarios donde corresponde.
577+
578+   Por ejemplo:
579+
580+``` pascal
581+ FLista: TList; // lista de TComponent
582+ FEntero: integer;
583+```
584+
585+   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+
587+``` pascal
588+ FLista: TList; { lista de TComponent
589+ Este es un comentario de varias líneas, comienza
590+ en la línea FLista, a la que la utilidad considera
591+ que pertenece y no romperá esta ligazón.
592+ El código se inserta después del comentario.}
593+ FEntero: integer;
594+```
595+
596+   Si el comentario comienza en la línea siguiente, será tratado como perteneciente al código que le sigue. Por ejemplo:
597+
598+``` pascal
599+ FLista: TList; // lista de TComponent
600+ { Este comentario está ligado a la sentencia precedente.
601+ El nuevo código será insertado delante del comentario
602+ a continuación del comentario de la línea de FLista. }
603+ FEntero: integer;
604+```
605+
606+## Refactorización (*Refactoring*)
607+
608+### Invertir Asignaciones
609+
610+   *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+
612+   Ejemplo:\
613+
614+``` pascal
615+ procedure HacerAlgo;
616+ begin
617+ AValueUnoStudio := BValorUno;
618+ AValorDos := BValorDos;
619+ AValorTres := BValorTres;
620+ end;
621+```
622+
623+   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+
625+``` pascal
626+ procedure HacerAlgo;
627+ begin
628+ BValorUno := AValueUnoStudio;
629+ BValorDos := AValorDos;
630+ BValorTres := AValorTres;
631+ end;
632+```
633+
634+### Encerrar Selección
635+
636+   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+
638+### Renombrar Identificador
639+
640+   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+
642+- Se renombra´na todas las ocurrencias que utilicen esta declaración. No lo hará con otras declaraciones con el mismo nombre.
643+- Primero comprueba los posibles conflictos de nombre.
644+- Límites: Únicamente funciona con código pascal, no cambia el nombre a archivos y no modifica archivos *lfm/lrs* ni archivos *lazdoc*.
645+
646+### Buscar referencias a identificador
647+
648+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+
650+### Mostrar métodos abstractos
651+
652+   Esta utilidad lista y crea el esquema de métodos virtuales y abstractos que necesitan ser implementados.
653+
654+   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+
656+### Extraer Procedimientos
657+
658+   Ver [[IDE Window: Extract Procedure/es|Extraer Procedimientos]]
659+
660+## Buscar Declaración
661+
662+   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+
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>.
665+
666+   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+
668+   La propiedad *Visible* está definida en primer lugar en *TControl* (controls.pp), está redefinida en *TCustomForm* y por último en *TForm*.
669+
670+   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+
672+   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+
674+``` pascal
675+ TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
676+ TColor = TGraphicsColor;
677+```
678+
679+   Y ocurre lo mismo con las clases definidas con antelación (*forward defined classes*): Por ejemplo en *TControl*, está esta variable privada
680+
681+``` pascal
682+ FHostDockSite: TWinControl;
683+```
684+
685+   Buscar declaración sobre *TWinControl* saltará a la definición previa (*forward defined classe*)
686+
687+``` pascal
688+ TWinControl = class;
689+```
690+
691+   Y haciéndolo de nuevo saltará a la implementación real
692+
693+``` pascal
694+ TWinControl = class(TControl)
695+```
696+
697+   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+
699+   **Sugerencia:** Puedes regresar al punto anterior al salto con <span class="kbd">Ctrl</span>+<span class="kbd">H</span>.
700+
701+## Completar Identificador
702+
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:
704+
705+``` pascal
706+ procedure TForm1.FormCreate(Sender: TObject);
707+ begin
708+ |
709+ end;
710+```
711+
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.
713+
714+**Nota para usuarios Delphi:** En Delphi esto se denomina *Completar Código*.
715+
716+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+
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.
719+
720+Completar identificador muestra incluso los identificadores que no son compatibles.
721+
722+### Prefijos
723+
724+   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+
726+``` pascal
727+ procedure TForm1.FormCreate(Sender: TObject);
728+ begin
729+ Ca|ption
730+ end;
731+```
732+
733+   Sólo se mostrarán los identificadores que comienzan por 'Ca'.
734+
735+### Teclas
736+
737+- 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'.
744+- Otras teclas: realizan su cometido normal y cierran la lista si es necesario.
745+
746+### Métodos
747+
748+   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+
750+``` pascal
751+ TMainForm = class(TForm)
752+ protected
753+ mous|
754+ end;
755+```
756+
757+   Completando con **MouseDown** obtendremos esto:
758+
759+``` pascal
760+ TMainForm = class(TForm)
761+ protected
762+ procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
763+ Y: Integer); override;
764+ end;
765+```
766+
767+### Propiedades
768+
769+``` pascal
770+ property MiEntero: integer read |;
771+```
772+
773+   Completar identificador mostrará en la lista ***FMiEntero**'' y***GetMiEntero**''.
774+
775+``` pascal
776+ property MiEntero: integer write |;
777+```
778+
779+   Completar identificador mostrará en la lista ***FMiEntero**'' y***SetMiEntero**''.
780+
781+### Sección *Uses* / nombres de unidad
782+
783+   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+
785+### Sentencias
786+
787+``` pascal
788+ procedure TMainForm.Button1Click(Sender: TObject);
789+ begin
790+ ModalRe|;
791+ end;
792+```
793+
794+   se convierte en:
795+
796+``` pascal
797+ procedure TMainForm.Button1Click(Sender: TObject);
798+ begin
799+ ModalResult:=|;
800+ end;
801+```
802+
803+## Completar palabra
804+
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*.
806+
807+## Ir a directiva de inclusión
808+
809+   *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+
811+## Publicar Proyecto
812+
813+   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+
815+   Un directorio normal de proyecto contiene mucha información, pero no es necesario hacerla pública toda:
816+
817+    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+
819+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+
821+   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+
823+   **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+
825+   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+
827+## Sugerencias desde comentarios
828+
829+   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+
831+   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+
833+### Comentarios mostrados en la sugerencia
834+
835+   Comentarios precediendo a una declaración, sin línea vacía y que no empiezan con el signo **\<**:
836+
837+``` pascal
838+ var
839+ {comentario}
840+ Identifier: integer;
841+```
842+
843+   Comentarios con el signo **\<** pertenecen al identificador precedente.
844+
845+   Comentarios detrás de un identificador en la misma línea:
846+
847+``` pascal
848+ var
849+ identifier, // comentario
850+ other,
851+```
852+
853+   Comentarios tras la definición en la misma línea:
854+
855+``` pascal
856+ var
857+ identifier:
858+ char; // comentario
859+```
860+
861+   Un ejemplo para el signo **\<**:
862+
863+``` pascal
864+ const
865+ a = 1;
866+ //< comentario para a
867+ b = 2;
868+ // comentario para c
869+ c = 3;
870+```
871+
872+   Los tres tipos de comentarios son compatibles:
873+
874+``` pascal
875+ {Comentario}(*Comentario*)//Comentario
876+ c = 1;
877+```
878+
879+   Los comentarios que empiezan con **\$** y **%** son ignorados.
880+
881+### Comentarios que no se muestra en la sugerencia
882+
883+   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+
885+``` pascal
886+ type
887+ { TMyClass }
888+
889+ TMyClass = class
890+```
891+
892+   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+
894+   El siguiente comentario será mostrado para GL_TRUE, pero no para GL_FALSE:
895+
896+``` pascal
897+ // Boolean
898+ GL_TRUE = 1;
899+ GL_FALSE = 0;
900+```
901+
902+## Contribuciones y cambios
903+
904+   Esta página ha sido convertida desde la [versión de epikwiki](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools).
905+
906+- Creación de la página y plantilla original - 4/6/2004 VlxAdmin
907+- Nuevo contenido inicial - 4/10/2004 MattiasG
908+- Pequeños retoque sobre formato - 4/11/2004 VlxAdmin
909+- Adición de la Tabla resumen de los atajos de las *IdeTools* - 12 July 2004 User:Kirkpatc
910+- Versión en castellano (español) iskraelectrica (jldc) / junio-julio de 2008.
911+
912+---
913+*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+Category: Castellano
915+Category: Español

Back to history