Difference between revisions of "Lazarus IDE Tools/es"

From Lazarus wiki
Jump to navigationJump to search
m (remove site-internal external links)
 
(99 intermediate revisions by 4 users not shown)
Line 9: Line 9:
 
{|
 
{|
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Find Declaration|Buscar Declaración]] || Ctrl+Click o Alt+Up (Salta a la declaración de la variable)
+
| [[#Buscar Declaración|Buscar Declaración]] || {{keypress|Ctrl}}+Click o {{keypress|Alt}}+{{keypress|Up}} (Salta a la declaración de la variable)
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Salto a Procedimiento|Salto a Procedimiento]] || Ctrl+Shift+Up (Salta entre la definición y el cuerpo de procedimientos y funciones)
+
| [[#Salto a Procedimiento|Salto a Procedimiento]] || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}} (Salta entre la definición y el cuerpo de procedimientos y funciones)
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Code Templates|Plantillas de Código]] || Ctrl+J
+
| [[#Plantillas de código|Plantillas de Código]] || {{keypress|Ctrl}}+{{keypress|J}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Code Completion|Completar Código]] || Ctrl+Shift+C (Completar Clase)
+
| [[#Syncro Edit|Edición sincronizada]] || {{keypress|Ctrl}}+{{keypress|J}} (cuándo hay texto seleccionado)
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Identifier Completion|Completar Identificador]] || Ctrl+Space
+
| [[#Completar Código|Completar Código]] || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} (Completar Clase)
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Word Completion|Completar Palabra]] || Ctrl+W
+
| [[#Completar Identificador|Completar Identificador]] || {{keypress|Ctrl}}+{{keypress|space}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/es#Parameter Hints|Ayuda de parámetros]] || Ctrl+Shift+Space
+
| [[#Completar palabra|Completar Palabra]] || {{keypress|Ctrl}}+{{keypress|W}}
 +
|-
 +
| [[#Sugerencia de Parámetros|Sugerencia de Parámetros]] || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|space}}
 +
|-
 +
| [[Incremental Search|Búsqueda incremental]] || {{keypress|Ctrl}}+{{keypress|E}}
 
|}
 
|}
  
 
==Salto a Procedimiento==
 
==Salto a Procedimiento==
   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'''''.
+
   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 {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}}.
  
 
   Por ejemplo:
 
   Por ejemplo:
<delphi> interface
+
<syntaxhighlight lang=pascal> interface
 
  procedure HacerAlgo; // declaración del procedimiento
 
  procedure HacerAlgo; // declaración del procedimiento
 
   //...   
 
   //...   
Line 36: Line 40:
 
  begin
 
  begin
 
   //...
 
   //...
  end;</delphi>
+
  end;</syntaxhighlight>
&nbsp;&nbsp;&nbsp;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''.
+
&nbsp;&nbsp;&nbsp;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 {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}} se regresa al cuerpo, y el cursor se sitúa al principio de la primera línea trás el ''begin''.
  
 
&nbsp;&nbsp;&nbsp;Esto funciona con procedimientos y funciones, sean o no miembros de una clase.
 
&nbsp;&nbsp;&nbsp;Esto funciona con procedimientos y funciones, sean o no miembros de una clase.
Line 44: Line 48:
  
 
&nbsp;&nbsp;&nbsp;Por ejemplo una función con diferente lista de parámetros:
 
&nbsp;&nbsp;&nbsp;Por ejemplo una función con diferente lista de parámetros:
<delphi> interface
+
<syntaxhighlight lang=pascal> interface
 
   
 
   
 
  function HacerAlgo(p: char); // declaración de la función
 
  function HacerAlgo(p: char); // declaración de la función
Line 52: Line 56:
 
  function HacerAlgo(p: string); // cuerpo de la función
 
  function HacerAlgo(p: string); // cuerpo de la función
 
  begin
 
  begin
  end;</delphi>  
+
  end;</syntaxhighlight>  
 
&nbsp;&nbsp;&nbsp;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.
 
&nbsp;&nbsp;&nbsp;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.
  
 
&nbsp;&nbsp;&nbsp;Por ejemplo:<br>
 
&nbsp;&nbsp;&nbsp;Por ejemplo:<br>
 
&nbsp;&nbsp;&nbsp;Remombramos 'HacerAlgo' a 'Hazlo':  
 
&nbsp;&nbsp;&nbsp;Remombramos 'HacerAlgo' a 'Hazlo':  
<delphi> interface
+
<syntaxhighlight lang=pascal> interface
 
   
 
   
 
  procedure Hazlo; // declaración del procedimiento
 
  procedure Hazlo; // declaración del procedimiento
Line 65: Line 69:
 
  procedure HacerAlgo; // Cuerpo del procedimiento
 
  procedure HacerAlgo; // Cuerpo del procedimiento
 
  begin
 
  begin
  end;</delphi>
+
  end;</syntaxhighlight>
 
&nbsp;&nbsp;&nbsp;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.
 
&nbsp;&nbsp;&nbsp;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.
  
 
==Archivos de inclusión==
 
==Archivos de inclusión==
El contenido de los archivos de inclusión es insertado en el código fuente con las directivas de compilación {$I filename} o {$INCLUDE filename}. 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.
+
&nbsp;&nbsp;&nbsp;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.
  
Contrary to Delphi, the Lazarus IDE has full support for include files. You can for example jump from the method in the .pas file to the method body in the include file. All codetools like code completion consider include files as special bounds.
+
&nbsp;&nbsp;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''.
 
   
 
   
For instance: When code completion adds a new method body behind another method body, it keeps them both in the same file. This way you can put whole class implementations in include files, like the LCL does for nearly all controls.
+
&nbsp;&nbsp;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.
  
But there is a newbie trap:
+
&nbsp;&nbsp;&nbsp;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.
If you open an include file for the first time and try method jumping or find declaration you will get an error. The IDE does not know to which unit the include file belongs. You must open the unit first.
 
  
As soon as the IDE parses the unit, it will parse the include directives there and the IDE will remember this relationship. It saves this information on exit and on project save to ~/.lazarus/includelinks.xml. The next time you open this include file and jump or do a find declaration, the IDE will internally open the unit and the jump will work.
+
&nbsp;&nbsp;&nbsp;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.
  
This mechanism has of course limits. Some include files are included twice or more. For example: lcl/include/winapih.inc.
+
&nbsp;&nbsp;&nbsp;Este mecanismo tiene límites, por supuesto. Algunos archivos están incluidos dos o más veces, por ejemplo, $(LazarusDir)/lcl/include/winapih.inc.
  
Jumping from the procedure/method definitions in this include file to the bodies depends on your last actions. If you worked on lcl/lclintf.pp the IDE will jump to winapi.inc. If you worked on lcl/interfacebase.pp, then it will jump to lcl/include/interfacebase.inc (or one of the other include files). If you are working on both, then you can get confused. ;)
+
&nbsp;&nbsp;&nbsp;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. ;)
  
==Code Templates==
+
==Plantillas de código==
Code Templates converts an identifier into a text or code fragment.
+
&nbsp;&nbsp;&nbsp;Las ''Plantillas de código'' permiten convertir un identificador en un texto o en un fragmento de código.
  
Code Templates default short cut is Ctrl+J. You can type an identifier, press Ctrl+J and the identifier is replaced by the text defined for the identifier. Code Templates can be defined in Environment -> Editor Options -> CodeTools.
+
&nbsp;&nbsp;&nbsp;El atajo, por defecto, para las ''Plantillas de código'' es {{keypress|Ctrl}}+{{keypress|J}}. Se escribe un identificador, se pulsan las teclas {{keypress|Ctrl}}+{{keypress|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...''.
  
Example:
+
&nbsp;&nbsp;Ejemplo:
Write the identifier 'classf', leave the cursor right behind the 'f' and press Ctrl+J. The 'classf' will be replaced by
+
&nbsp;&nbsp;Escribimos el identificador 'classf', con el cursor justo a la derecha de la 'f' pulsamos las teclas {{keypress|Ctrl}}+{{keypress|J}} y 'classf' será reemplazado por
T = class(T)
+
<syntaxhighlight lang=pascal> TClass = class(TBase)
 
  private
 
  private
 
   
 
   
Line 97: Line 101:
 
   constructor Create;
 
   constructor Create;
 
   destructor Destroy; override;
 
   destructor Destroy; override;
  end;
+
  end;</syntaxhighlight>
and the cursor is behind the 'T'.
+
además el cursor de posicionará en 'TClass'.
You can get the list of templates by positioning the cursor on space (not on an identifier) and pressing Ctrl+J. The list of code templates will pop up. Use the cursor keys or type some chars to choose one. Return creates the selected template and Escape closes the pop up.
+
 
 +
&nbsp;&nbsp;&nbsp;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.
 +
 
 +
&nbsp;&nbsp;La plantilla que más tiempo nos ahorrará es 'b'+{{keypress|Ctrl}}+{{keypress|J}} para begin..end.
 +
 
 +
==Sugerencia de Parámetros==
 +
 
 +
&nbsp;&nbsp;&nbsp;''Sugerencia de Parámetros'' muestra una caja con la lista de posibles declaraciones con sus parámetros para el procedimiento o función actual.
 +
 
 +
&nbsp;&nbsp;&nbsp;Por ejemplo:
 +
 
 +
<syntaxhighlight lang=pascal> Canvas.FillRect(|);</syntaxhighlight>
 +
 
 +
&nbsp;&nbsp;&nbsp;Situamos el cursor dentro de los paréntesis y pulsamos {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|space}}. La lista de sugerencias aparecerá con los posibles parámetros, según las distintas declaraciones de ''FillRect''.
 +
 
 +
[[Image:Parameterhints1.png]]
 +
 
 +
&nbsp;&nbsp;&nbsp;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.
 +
 
 +
[[Image:Parameterhints2.png]]
 +
 
 +
&nbsp;&nbsp;&nbsp;Consejo: Utiliza [[#Variable Declaration Completion|Completar Declaración de Variable]] para declarar las variables.
 +
 
 +
&nbsp;&nbsp;&nbsp;Nota: El nombre del atajo es "Show code context" (Mostrar Contexto del Código).
  
The biggest time savers are templates 'b'+Ctrl+J for begin..end.
+
==Búsqueda incremental==
  
==Parameter Hints==
+
&nbsp;&nbsp;&nbsp;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 {{keypress|Ctrl}}+{{keypress|e}}.
 +
*Por ejemplo pulsa {{keypress|e}}  buscará y resaltará todas las apariciones de 'e'.
 +
*Pulsa {{keypress|t}} buscará y resaltará todas las apariciones de 'et' y así sucesivamente.
 +
*Puede saltar a la siguiente con {{keypress|F3}} (o {{keypress|Ctrl}}+{{keypress|e}} mientras se busca) y a la previa con {{keypress|Shift}}+{{keypress|F3}}.
 +
*{{keypress|Backspace}} elimina el último carácte
 +
*{{keypress|Enter}} detiene la búsqueda sin añadir una nueva línea en el editor.
 +
*Puedes volver a la última búsqueda pulsando {{keypress|Ctrl}}+{{keypress|e}} una segunda vez, inmediatamente después de que empezó con la búsqueda con {{keypress|Ctrl}}+{{keypress|e}} es decir, mientras que el término de búsqueda está vacío.
 +
*Pegar: {{keypress|Ctrl}}+{{keypress|V}} adjuntará el texto del portapapeles al texto de búsqueda actuales (desde lazarus 0.9.27 r19824).
  
Parameter Hints shows a hint box with the parameter declarations for the current parameter list.
+
===Sugerencia: Búsqueda rápida de un identificador con búsqueda incremental===
  
For example
+
*Mueve el cursor del texto sobre el identificador (no selecciones nada)
 +
*Pulsa {{keypress|Ctrl}}+{{keypress|C}}. En el editor de código fuente se selecciona el identificador y se copia en el portapapeles
 +
*Pulsa {{keypress|Ctrl}}+{{keypress|E}} para iniciar la búsqueda incremental
 +
*Pulsa {{keypress|Ctrl}}+{{keypress|V}} para buscar el identificador (desde 0.9.27)
 +
*Usa {{keypress|F3}} y {{keypress|Shift}}+{{keypress|F3}} para ir rápidamente a siguiente / anterior.
 +
*Usa cualquier tecla (por ejemplo, el cursor hacia la izquierda o la derecha) para finalizar la búsqueda.
  
  Canvas.FillRect(|);
+
==Edición sincronizada==
  
Place the cursor in the brackets and press Ctrl+Shift+Space. A hint box will show up showing the parameters of FillRect.
+
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.
  
==Code Completion==
+
Edición sincronizada funciona en todas las palabras en un área seleccionada:
Code Completion can be found in the IDE menu Edit -> Complete Code and has as standard short cut Ctrl+Shift+C.
+
* Selecciona un bloque de texto
 +
* pulsa {{keypress|Ctrl}}+{{keypress|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.
 +
* usa la tecla {{keypress|tab}} para seleccionar la palabra que deseas editar (en caso de que varias palabras diferentes se repitan más de una vez)
 +
* Edita la palabra
 +
* pulsa {{keypress|Esc}} para terminar
 +
Ver un ejemplo animado [[New_IDE_features_since#Syncron-Edit|aquí]]
 +
* Nota: {{keypress|Ctrl}}+{{keypress|J}}  también se utiliza para editar plantillas. Cambia su significado si hay seleccionado algo de texto.
  
For Delphians:
+
==Completar Código==
Delphi calls "code completion" the function showing the list of identifiers at the current source position (Ctrl+Space). Under Lazarus this is called "Identifier completion".
+
&nbsp;&nbsp;&nbsp;Completar código se encuentra en el menú Editar del IDE y su atajo por defecto es {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}}. También Aparece en el menú contextual Refactoring -> Completar código.
  
Code Completion combines several powerful functions. Examples:
+
&nbsp;&nbsp;&nbsp;Para usuarios de Delphi:
* Class Completion: completes properties, adds method bodies, add private variables and private access methods
+
&nbsp;&nbsp;En Delphi "code completion"  muestra la lista de identificadores en la posición actual del código ({{keypress|Ctrl}}+{{keypress|Space}}). En Lazarus esta función se llama "Completar identificador".
* Forward Procedure Completion: adds procedure bodies
 
* Event Assignment Completion: completes event assignments and adds method definition and body
 
* Variable Declaration Completion: adds local variable definitions
 
* Procedure Call Completion: adds a new procedure
 
* Reversed procedure completion: adds procedure declarations for procedure/function bodies
 
* Reversed class completion: adds method declarations for method bodies
 
  
Which function is used, depends on the cursor position in the editor.  
+
&nbsp;&nbsp;&nbsp;Completar código combina varias potentes funciones. Ejemplos:
 +
* [[#Class Completion|Completar Clase]] (''Class Completion''): completa propiedades, añade cuerpos de métodos, añade variables y métodos privados.
 +
* [[#Forward Procedure Completion|Completar procedimiento]] (''Forward Procedure Completion''): añade cuerpos de procedimientos.
 +
* [[#Event Assignment Completion|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.
 +
* [[#Variable Declaration Completion|Completar declaración de variables]] (''Variable Declaration Completion''): añade la declaración de variables locales.
 +
* [[#Procedure Call Completion|Completar llamada a procedimiento]] (''Procedure Call Completion''): añade un nuevo procedimiento.
 +
* [[#Reversed Procedure Completion|Completar procedimiento inverso]] (''Reversed procedure completion''): añade la definición de cuerpos para procedimientos y funciones.
 +
* [[#Reversed Class Completion|Completar clase inversa]] (''Reversed class completion''): añade declaraciones para cuerpos de métodos.
  
Code Completion can be found in the IDE menu Edit -> Complete Code and has as standard short cut Ctrl+Shift+C.
+
&nbsp;&nbsp;&nbsp;La función que se activa depende de la posición del cursor en el editor de código.
  
===Class Completion===
+
===Completar Clase===
  
The most powerful code completion feature is "Class Completion". You write a class, add the methods and properties and Code Completion will add the method bodies, the property access methods/variables and the private variables.  
+
&nbsp;&nbsp;&nbsp;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.  
  
For example: Create a class (see Code Templates to save you some type work):  
+
&nbsp;&nbsp;&nbsp;Por ejemplo: crea una clase (utiliza [[IDE_Window:_Code_Templates/es|Platillas de código]] para ahorrarte trabajo de escritura):  
  
TExample = class(TObject)
+
<syntaxhighlight lang=pascal> TEjemplo = class(TObject)
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
 
   destructor Destroy; override;
 
   destructor Destroy; override;
  end;
+
  end;</syntaxhighlight>
Position the cursor somewhere in the class and press Ctrl+Shift+C. This will create the method missing bodies and move the cursor to the first created method body, so you can just start writing the class code:  
+
&nbsp;&nbsp;&nbsp;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:  
  
{ TExample }
+
<syntaxhighlight lang=pascal> { TEjemplo }
 
   
 
   
  constructor TExample.Create;
+
  constructor TEjemplo.Create;
 
  begin
 
  begin
 
   |
 
   |
 
  end;
 
  end;
 
   
 
   
  destructor TExample.Destroy;
+
  destructor TEjemplo.Destroy;
 
  begin
 
  begin
 
   inherited Destroy;
 
   inherited Destroy;
  end;
+
  end;</syntaxhighlight>
Note: The '|' is the cursor and is not added.  
+
&nbsp;&nbsp;&nbsp;Nota: El carácter '|' representa el cursor.  
  
Hint: You can jump between a method and its body with Ctrl+Shift+Up.  
+
&nbsp;&nbsp;&nbsp;Sugerencia: puedes saltar entre la definición y el cuerpo de un método con {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}}.  
  
You can see, that the IDE added the 'inherited Destroy' call too. This is done, if there is an 'override' keyword in the class definition.  
+
&nbsp;&nbsp;&nbsp;Cómo se puede ver, el IDE añade la llamada 'inherited Destroy' siempre que el método esté definido con ''override''.  
  
Now add a method DoSomething:  
+
&nbsp;&nbsp;&nbsp;Ahora añade un método HacerAlgo:  
  
TExample = class(TObject)
+
<syntaxhighlight lang=pascal> TEjemplo = class(TObject)
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
   procedure DoSomething(i: integer);
+
   procedure HacerAlgo(i: integer);
 
   destructor Destroy; override;
 
   destructor Destroy; override;
  end;
+
  end;</syntaxhighlight>
Then press Ctrl+Shift+C and the IDE will add
+
&nbsp;&nbsp;&nbsp;Ahora se pulsa {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} y el IDE añadirá
  
procedure TExample.DoSomething(i: integer);
+
<syntaxhighlight lang=pascal> procedure TEjemplo.HacerAlgo(i: integer);
 
  begin
 
  begin
 
   |
 
   |
  end;
+
  end;</syntaxhighlight>
You can see, that the new method body is inserted between Create and Destroy, exactly as in the class definition. This way the bodies keep the same logical ordering as you define. You can define the insertion policy in Environment > Codetools Options -> Code Creation.  
+
&nbsp;&nbsp;&nbsp;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.
  
'''Complete Properties'''<br>
+
====Completar Propiedades====
Add a property AnInteger:
+
&nbsp;&nbsp;&nbsp;Añade la propiedad UnEntero:
TExample = class(TObject)
+
<syntaxhighlight lang=pascal> TEjemplo = class(TObject)
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
   procedure DoSomething(i: integer);
+
   procedure HacerAlgo(i: integer);
 
   destructor Destroy; override;
 
   destructor Destroy; override;
   property AnInteger: Integer;
+
   property UnEntero: Integer;
  end;
+
  end;</syntaxhighlight>
Press Ctrl+Shift+C and you will get:
+
&nbsp;&nbsp;&nbsp;Pulsa Ctrl+Shift+C y obtendrás esto:
procedure TExample.SetAnInteger(const AValue: integer);
+
<syntaxhighlight lang=pascal> procedure TEjemplo.SetUnEntero(const AValue: integer);
 
  begin
 
  begin
   |if FAnInteger=AValue then exit;
+
   |if FUnEntero=AValue then exit;
   FAnInteger:=AValue;
+
   FUnEntero:=AValue;
  end;
+
  end;</syntaxhighlight>
The code completion has added a Write access modifier and added some common code.
+
&nbsp;&nbsp;&nbsp;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 {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}} para ver los cambio realizados en la clase:
Jump to the class with Ctrl+Shift+Up to see the new class:
+
<syntaxhighlight lang=pascal> TEjemplo = class(TObject)
TExample = class(TObject)
 
 
  private
 
  private
   FAnInteger: integer;
+
   FUnEntero: integer;
   procedure SetAnInteger(const AValue: integer);
+
   procedure SetUnEntero(const AValue: integer);
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
   procedure DoSomething(i: integer);
+
   procedure HacerAlgo(i: integer);
 
   destructor Destroy; override;
 
   destructor Destroy; override;
   property AnInteger: integer read FAnInteger write SetAnInteger;
+
   property UnEntero: integer read FUnEntero write SetUnEntero;
  end;
+
  end;</syntaxhighlight>
The property was extended by a Read and Write access modifier. The class got the new section 'private' with a Variable 'FAnInteger' and the method 'SetAnInteger'.
+
&nbsp;&nbsp;&nbsp; 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'.
It is a common Delphi style rule to prepend private variables with an 'F' and the write method with a 'Set'. If you don't like that, you can change this in Environment > Codetools Options -> Code Creation.
+
&nbsp;&nbsp;&nbsp;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.
  
Creating a read only property:
+
&nbsp;&nbsp;&nbsp;Crear una propiedad de sólo lectura:
property PropName: PropType read;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad read;</syntaxhighlight>
Will be expanded to
+
&nbsp;&nbsp;&nbsp;Se expandirá a
property PropName: PropType read FPropName;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad read FNombrePropiedad;</syntaxhighlight>
Creating a write only property:
+
&nbsp;&nbsp;&nbsp;Crear una propiedad de sólo escritura:
  property PropName: PropType write;
+
<syntaxhighlight lang=pascal>  property NombrePropiedad: TipoPropiedad write;</syntaxhighlight>
Will be expanded to
+
&nbsp;&nbsp;&nbsp;Se expandirá a
property PropName: PropType write SetPropName;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad write SetNombrePropiedad;</syntaxhighlight>
Creating a read only property with a Read method:
+
&nbsp;&nbsp;&nbsp;Crear una propiedad de sólo lectura con una función de lectura:
property PropName: PropType read GetPropName;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad read GetNombrePropiedad;</syntaxhighlight>
Will be kept and a GetPropName function will be added:
+
&nbsp;&nbsp;&nbsp;La función GetNombrePropiedad será añadida:
function GetpropName: PropType;
+
<syntaxhighlight lang=pascal> function GetNombrePropiedad: TipoPropiedad;</syntaxhighlight>
Creating a property with a stored modifier:
+
&nbsp;&nbsp;&nbsp;Crear una propiedad con un modificador 'stored':
property PropName: PropType stored;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad stored;</syntaxhighlight>
Will be expanded to
+
&nbsp;&nbsp;&nbsp;Se expandirá a
property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad read FNombrePropiedad write SetNombrePropiedad stored NombrePropiedadIsStored;</syntaxhighlight>
Because stored is used for streaming read and write modifiers are automatically added as well.
+
&nbsp;&nbsp;&nbsp;Cómo ''stored'' se utiliza para el ''streaming'' los modificadores ''read'' y ''write'' se añaden automáticamente.
  
Hint:
+
&nbsp;&nbsp;&nbsp;Sugerencia:
Identifier completion also recognizes incomplete properties and will suggest the default names. For example:
+
Completar identificador también reconoce propiedades incompletas, sugiriendo los nombres por defecto. Por ejemplo:
property PropName: PropType read |;
+
<syntaxhighlight lang=pascal> property NombrePropiedad: TipoPropiedad read |;</syntaxhighlight>
Place the cursor one space behind the 'read' keyword and press Ctrl+Space for the identifier completion. It will present you the variable 'FPropName' and the procedure 'SetPropName'.
+
&nbsp;&nbsp;&nbsp;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'.
  
===Forward Procedure Completion===
+
===Completar Procedimiento declarado===
"Forward Procedure Completion" is part of the Code Completion and adds missing procedure bodies. It is invoked, when the cursor is on a forward defined procedure.
+
&nbsp;&nbsp;&nbsp;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.
  
For example:
+
&nbsp;&nbsp;&nbsp;Por ejeamplo:
Add a new procedure to the interface section:
+
&nbsp;&nbsp;&nbsp;Añade un nuevo procedimiento en la sección ''interface'':
procedure DoSomething;
+
<syntaxhighlight lang=pascal> procedure HacerAlgo;</syntaxhighlight>
Place the cursor on it and press Ctrl+Shift+C for code completion. It will create in the implementation section:
+
&nbsp;&nbsp;&nbsp;Sitúa el cursor sobre ella y pulsa {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} para completar el código. Se creará lo siguiente en la sección de implementación:
procedure DoSomething;
+
<syntaxhighlight lang=pascal> procedure HacerAlgo;
 
  begin
 
  begin
 
   |
 
   |
  end;
+
  end;</syntaxhighlight>
Hint: You can jump between a procedure definition and its body with Ctrl+Shift+Up.
+
&nbsp;&nbsp;&nbsp;Nota: puedes saltar alternativamente entre el cuerpo del procedimiento y su definición pulsando {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}}.
  
The new procedure body will be added in front of the class methods. If there are already some procedures in the interface the IDE tries to keep the ordering. For example:
+
&nbsp;&nbsp;&nbsp;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:
  procedure Proc1;
+
<syntaxhighlight lang=pascal>  procedure Proc1;
   procedure Proc2; // new proc
+
   procedure Proc2; // nuevo procedimiento
   procedure Proc3;
+
   procedure Proc3;</syntaxhighlight>
If the bodies of Proc1 and Proc3 already exists, then the Proc2 body will be inserted between the bodies of Proc1 and Proc3. This behaviour can be setup in Environment > Codetools Options -> Code Creation.
+
&nbsp;&nbsp;&nbsp;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.
  
Multiple procedures:
+
&nbsp;&nbsp;&nbsp;Varios procedimientos:
procedure Proc1_Old; // body exists
+
<syntaxhighlight lang=pascal> procedure Proc1_Viejo; // el cuerpo existe
  procedure Proc2_New; // body does not exists
+
  procedure Proc2_Nuevo; // el cuerpo No existe
  procedure Proc3_New; //  "
+
  procedure Proc3_Nuevo; //  "
  procedure Proc4_New; //  "
+
  procedure Proc4_Nuevo; //  "
  procedure Proc5_Old; // body exists
+
  procedure Proc5_Existente; // el cuerpo existe</syntaxhighlight>
Code Completion will add all 3 procedure bodies (Proc2_New, Proc3_New, Proc4_New).
+
&nbsp;&nbsp;&nbsp;Completar código añadirá los cuerpos de los tres procedimientos(Proc2_Nuevo, Proc3_Nuevo, Proc4_Nuevo).
  
Why calling it "Forward Procedure Completion"?
+
&nbsp;&nbsp;&nbsp;¿Porqué se llama ''Forward Procedure Completion''?
  
Because it does not only work for procedures defined in the interface, but for procedures with the "forward" modifier as well. And because the codetools treats procedures in the interface as having an implicit 'forward' modifier.
+
&nbsp;&nbsp;&nbsp;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.
  
===Event Assignment Completion===
+
===Completar asignación de eventos===
"Event Assignment Completion" is part of the Code Completion and completes a single Event:=| statement. It is invoked, when the cursor is behind an assignment to an event.
+
&nbsp;&nbsp;&nbsp;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.
  
For example:
+
&nbsp;&nbsp;&nbsp;Por ejemplo:
In a method, say the FormCreate event, add a line 'OnPaint:=':
+
&nbsp;&nbsp;&nbsp;En un método, el evento FormCreate mismamente, añade la línea 'OnPaint:=':
procedure TForm1.Form1Create(Sender: TObject);
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
 
  begin
 
  begin
 
   OnPaint:=|
 
   OnPaint:=|
  end;
+
  end;</syntaxhighlight>
The '|' is the cursor and should not be typed.
+
&nbsp;&nbsp;&nbsp;El caracter '|' representa el cursor y no hay que escribirlo. Pulsa Ctrl+Shift+C para completar el código. La sentencia se completará con
Then press Ctrl+Shift+C for code completion. The statement will be completed to
+
<syntaxhighlight lang=pascal> OnPaint:=@Form1Paint;</syntaxhighlight>
OnPaint:=@Form1Paint;
+
&nbsp;&nbsp;&nbsp;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:
A new method Form1Paint will be added to the TForm1 class. Then class completion is started and you get:
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Paint(Sender: TObject);
procedure TForm1.Form1Paint(Sender: TObject);
 
 
  begin
 
  begin
 
   |
 
   |
  end;
+
  end;</syntaxhighlight>
This works just like adding methods in the object inspector.
+
&nbsp;&nbsp;&nbsp;El comportamiento es el mismo que cuándo en el inspector de objetos añadimos código para un evento de un objeto.
  
Note:<br>
+
&nbsp;&nbsp;&nbsp;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.
You must place the cursor behind the ':=' assignment operator. If you place the cursor on the identifier (e.g. OnPaint) code completion will invoke "Local Variable Completion", which fails, because OnPaint is already defined.
 
  
Hint:<br>
+
&nbsp;&nbsp;&nbsp;Sugerencia: nosotros podemos definir el nombre del método, por ejemplo:
You can define the new method name by yourself. For example:
+
<syntaxhighlight lang=pascal> OnPaint:=@ElMetodoParaPintar;</syntaxhighlight>
  OnPaint:=@ThePaintMethod;
+
&nbsp;&nbsp;&nbsp;Para ello hay que situar el cursor sobre el nombre del método antes de llamar a completar código con {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}}.
  
===Variable Declaration Completion===
+
===Completar Declaración de Variable===
"Variable Declaration Completion" is part of the Code Completion and adds a local variable definition for a Identifier:=Term; statement. It is invoked, when the cursor is on the identifier of an assignment or a parameter.
+
&nbsp;&nbsp;&nbsp;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.
  
For example:
+
&nbsp;&nbsp;&nbsp;Por ejemplo:
<delphi>
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
procedure TForm1.Form1Create(Sender: TObject);
+
begin
begin
 
 
   i:=3;
 
   i:=3;
end;
+
end;</syntaxhighlight>
</delphi>
+
&nbsp;&nbsp;&nbsp; Sitúa el cursor en la 'i' o justo detrás. Púlsa {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} para completar el código y se obtiene:
Place the cursor on the 'i' or just behind it. Then press Ctrl+Shift+C for code completion and you will get:
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
<delphi>
+
var
procedure TForm1.Form1Create(Sender: TObject);
 
var
 
 
   i: Integer;
 
   i: Integer;
begin
+
begin
 
   i:=3;
 
   i:=3;
end;
+
end;</syntaxhighlight>
</delphi>
+
&nbsp;&nbsp;&nbsp;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.
The codetools first checks, if the identifier 'i' is already defined and if not it will add the declaration 'var i: integer;'. The type of the identifier is guessed from the term right to the assignment ':=' operator. Numbers like the 3 defaults to Integer.
 
  
Another example:
+
&nbsp;&nbsp;&nbsp;Otro ejemplo:
<delphi>
+
<syntaxhighlight lang=pascal> type
type
+
   TDonde = (Final, Mitad, Principio);
   TWhere = (Behind, Middle, InFront);
 
 
   
 
   
 
   procedure TForm1.Form1Create(Sender: TObject);
 
   procedure TForm1.Form1Create(Sender: TObject);
 
   var
 
   var
     a: array[TWhere] of char;
+
     a: array[TDonde] of char;
 
   begin
 
   begin
     for Where:=Low(a) to High(a) do writeln(a[Where]);
+
     for Donde:=Low(a) to High(a) do writeln(a[Donde]);
   end;
+
   end;</syntaxhighlight>
</delphi>
+
&nbsp;&nbsp;&nbsp;Sitúa el cursor en 'Donde' y pulsa {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}}, obtendrás:
Place the cursor on 'Where' and press Ctrl+Shift+C for code completion. You get:
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
<delphi>
 
  procedure TForm1.Form1Create(Sender: TObject);
 
 
   var
 
   var
     a: array[TWhere] of char;
+
     a: array[TDonde] of char;
     Where: TWhere;
+
     Donde: TDonde;
 
   begin
 
   begin
     for Where:=Low(a) to High(a) do writeln(a[Where]);
+
     for Donde:=Low(a) to High(a) do writeln(a[Donde]);
   end;
+
   end;</syntaxhighlight>
</delphi>
 
  
Since 0.9.11 Lazarus also completes parameters. For example
+
&nbsp;&nbsp;&nbsp;Desde la versión 0.9.11 Lazarus también completa parámetros. Por ejemplo
<delphi>
+
<syntaxhighlight lang=pascal> procedure TForm1.FormPaint(Sender: TObject);
  procedure TForm1.FormPaint(Sender: TObject);
 
 
   begin
 
   begin
 
     with Canvas do begin
 
     with Canvas do begin
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
</delphi>
+
&nbsp;&nbsp;&nbsp;Sitúa el cursor en 'x1' y pulsa {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}}, obtendrás:
Place the cursor on 'x1' and press Ctrl+Shift+C for code completion. You get:
+
<syntaxhighlight lang=pascal> procedure TForm1.FormPaint(Sender: TObject);
<delphi>
 
  procedure TForm1.FormPaint(Sender: TObject);
 
 
   var
 
   var
 
     x1: integer;
 
     x1: integer;
Line 350: Line 382:
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
</delphi>
 
  
===Procedure Call Completion===
+
===Completar Llamada a procedimiento===
Code completion can create a new procedure from a call statement itself.
+
&nbsp;&nbsp;&nbsp;'''Nota de traductor:''' lo que sigue no funciona, si lo intentamos no hace nada.
  
Assume you just wrote the statement "DoSomething(Width);"
+
&nbsp;&nbsp;&nbsp;Completar código  creará un nuevo procedimiento desde la orden de invocación.
<delphi>
 
procedure SomeProcedure;
 
var
 
  Width: integer;
 
begin
 
  Width:=3;
 
  DoSomething(Width);
 
end;
 
</delphi>
 
  
Position the cursor over the identifier "DoSomething" and press Ctrl+Shift+C to get:
+
&nbsp;&nbsp;&nbsp;Supongamos que acabas de escribir la orden ''HacerAlgo(Ancho);''
 +
<syntaxhighlight lang=pascal> procedure UnProcedimiento;
 +
var
 +
  Ancho: integer;
 +
begin
 +
  Ancho:=3;
 +
  HacerAlgo(Ancho);
 +
end;</syntaxhighlight>
  
<delphi>
+
&nbsp;&nbsp;&nbsp;Coloca el cursor sobre el identificador "HacerAlgo" y pulsa {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} para obtener:
procedure DoSomething(aWidth: LongInt);
 
begin
 
  
end;
+
<syntaxhighlight lang=pascal> procedure HacerAlgo(aWidth: LongInt);
 +
begin
  
procedure SomeProcedure;
+
end;
var
+
 
  Width: integer;
+
procedure UnProcedimiento;
begin
+
  var
 +
  Width: integer;
 +
begin
 
   Width:=3;
 
   Width:=3;
   DoSomething(Width);
+
   HacerAlgo(Width);
end;
+
end;</syntaxhighlight>
</delphi>
 
  
It does not yet create functions nor methods.
+
===Completar Clase inversa===
  
===Reversed Class Completion===
+
&nbsp;&nbsp;&nbsp;"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 ...''.
 +
 +
&nbsp;&nbsp;&nbsp;Esta función está disponible desde la versión 0.9.21 de Lazarus.
  
"Reversed Class Completion" is part of the '''Code Completion''' and adds a private method declaration for the current method body. It is invoked, when the cursor is in a method body, not yet defined in the class.
+
&nbsp;&nbsp;&nbsp;Por ejemplo:
This feature is available since Lazarus 0.9.21.
+
<syntaxhighlight lang=pascal>  procedure TForm1.HacerAlgo(Emisor: TObject);
 +
  begin
 +
  end;</syntaxhighlight>
  
For example:
+
&nbsp;&nbsp;&nbsp;El método HacerAlgo no está declarado en TForm1. Pulsar {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} y el IDE añadirá "procedure HacerAlgo(Emisor: TObject);" en la definición de la clase TForm1.
  procedure TForm1.DoSomething(Sender: TObject);
 
  begin
 
  end;
 
  
The method DoSomething is not yet declared in TForm1. Press Ctrl+Shift+C and the IDE will add "procedure DoSomething(Sender: TObject);" to the private methods of TForm1.
+
&nbsp;&nbsp;&nbsp;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.
  
For Delphians:
+
===Comentarios y ''Completar código''===
Class completion works under Lazarus always in one way: From class interface to implementation or backwards/reversed from class implementation to interface. Delphi always invokes both directions. The Delphi way has the disadvantage, that if a typo will easily create a new method stub without noticing.
+
&nbsp;&nbsp;&nbsp;''Completar código'' procura mantener los comentarios donde corresponde.  
  
===Comments and Code Completion===
+
&nbsp;&nbsp;&nbsp;Por ejemplo:
Code completion tries to keep comments where they belong.
+
<syntaxhighlight lang=pascal>  FLista: TList; // lista de TComponent
For example:
+
   FEntero: integer;</syntaxhighlight>
  FList: TList; // list of TComponent
+
&nbsp;&nbsp;&nbsp;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
   FInt: integer;
+
<syntaxhighlight lang=pascal>  FLista: TList; { lista de TComponent
When inserting a new variable between FList and FInt, the comment is kept in the FList line. Same is true for
+
     Este es un comentario de varias líneas, comienza
  FList: TList; { list of TComponent
+
     en la línea FLista, a la que la utilidad considera
     This is a comment over several lines, starting
+
     que pertenece y no romperá esta ligazón.
     in the FList line, so codetools assumes it belongs
+
     El código se inserta después del comentario.}
     to the FLIst line and will not break this
+
   FEntero: integer;</syntaxhighlight>
     relationship. Code is inserted behind the comment. }
+
&nbsp;&nbsp;&nbsp;Si el comentario comienza en la línea siguiente, será tratado como perteneciente al código que le sigue. Por ejemplo:
   FInt: integer;
+
<syntaxhighlight lang=pascal>  FLista: TList; // lista de TComponent
If the comment starts in the next line, then it will be treated as if it belongs to the code below. For example:
+
     { Este comentario está ligado a la sentencia precedente.  
  FList: TList; // list of TComponent
+
       El nuevo código será insertado delante del comentario
     { This comment belongs to the statement below.  
+
       a continuación del comentario de la línea de FLista. }
       New code is inserted above this comment and
+
   FEntero: integer;</syntaxhighlight>
       behind the comment of the FList line. }
 
   FInt: integer;
 
  
==Refactoring==
+
==Refactorización (''Refactoring'')==
  
===Invert Assignments===
+
===Invertir Asignaciones===
  
;Abstract: : "Invert Assignments" takes some selected pascal statements and inverts all assignments from this code. This tool is usefull for transforming a "save" code to a "load" one and inverse operation.
+
&nbsp;&nbsp;&nbsp;''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.
  
Example:<br>
+
&nbsp;&nbsp;&nbsp;Ejemplo:<br>
  procedure DoSomething;
+
<syntaxhighlight lang=pascal> procedure HacerAlgo;
 +
begin
 +
  AValueUnoStudio := BValorUno;
 +
  AValorDos := BValorDos;
 +
  AValorTres := BValorTres;
 +
end;</syntaxhighlight>
 +
&nbsp;&nbsp;&nbsp;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:
 +
<syntaxhighlight lang=pascal> procedure HacerAlgo;
 
  begin
 
  begin
  AValueStudio:= BValueStudio;
+
  BValorUno  := AValueUnoStudio;
  AValueAppartment :=BValueAppartment;
+
  BValorDos  := AValorDos;
  AValueHouse:=BValueHouse;
+
  BValorTres := AValorTres;
  end;
+
  end;</syntaxhighlight>
Select the lines with assignments (between begin and end) and do Invert Assignments. All assignments will be inverted and identation will be add automatically. For example:
+
 
 +
===Encerrar Selección===
 +
&nbsp;&nbsp;&nbsp;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.
 +
 
 +
===Renombrar Identificador===
 +
&nbsp;&nbsp;&nbsp;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.
 +
* Se renombra´na todas las ocurrencias que utilicen esta declaración. No lo hará con otras declaraciones con el mismo nombre.
 +
* Primero comprueba los posibles conflictos de nombre.
 +
* Límites: Únicamente funciona con código pascal, no cambia el nombre a archivos y no modifica archivos ''lfm/lrs'' ni archivos ''lazdoc''.
  
Result:
+
===Buscar referencias a identificador===
procedure DoSomething;
+
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.
begin
 
  BValueStudio    := AValueStudio;
 
  BValueAppartment := AValueAppartment;
 
  BValueHouse      := AValueHouse;
 
end;
 
===Enclose Selection===
 
Select some text and invoke it. A dialog will popup where you can select if the selection should be enclosed into '''try..finally''' or many other common blocks.
 
  
===Rename Identifier===
+
===Mostrar métodos abstractos===
Place the cursor on an identifier and invoke it. A dialog will appear, where you can setup the search scope and the new name.
+
&nbsp;&nbsp;&nbsp;Esta utilidad lista y crea el esquema de métodos virtuales y abstractos que necesitan ser implementados.
* It will rename all occurences and only those that actually use this declaration. That means it does not rename declarations with the same name.
 
* And it will first check for name conflicts.
 
* Limits: It only works on pascal sources, does not yet rename files nor adapt lfm/lrs files nor lazdoc files.
 
  
===Find Identifier References===
+
&nbsp;&nbsp;&nbsp;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.
Place the cursor on an identifier and invoke it. A dialog will appear, where you can setup the search scope. The IDE will then search for all occurences and only those that actually use this declaration. That means it does not show other declarations with the same name.
 
  
===Show abstract methods===
+
===Extraer Procedimientos===
This feature lists and auto completes virtual, abstracts methods that need to be implemented.
 
Place the cursor on a class declaration and invoke it. If there are missing abstract methods a dialog will appear listing them. Select the methods to implement and the IDE creates the method stubs.
 
  
===Extract Procedure===
+
&nbsp;&nbsp;&nbsp;Ver [[IDE_Window:_Extract_Procedure/es|Extraer Procedimientos]]
  
See [[IDE_Window:_Extract_Procedure|Extract Procedure]]
+
==Buscar Declaración==
 +
&nbsp;&nbsp;&nbsp;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
  
==Find Declaration==
+
&nbsp;&nbsp;&nbsp;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 {{keypress|Ctrl}}+{{keypress|H}}.
Position the cursor on an identifier and do 'Find Declaration'. Then it will search the declaration of this identifier, open the file and jump to it.
 
  
Every find declaration sets a Jump Point. That means you jump with find declaration to the declaration and easily jump back with Search -> Jump back.
+
&nbsp;&nbsp;&nbsp;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:
  
There are some differences to Delphi:
+
&nbsp;&nbsp;&nbsp;La propiedad ''Visible'' está definida en primer lugar en ''TControl'' (controls.pp), está redefinida en ''TCustomForm'' y por último en ''TForm''.
The codetools work on sources following the normal pascal rules, instead of using the compiler output. The compiler returns the final type. The codetools see the sources and all steps in between. For example:
 
  
The ''Visible'' property is first defined in TControl (controls.pp), then redefined in TCustomForm and finally redefined in TForm.
+
&nbsp;&nbsp;&nbsp;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''.
Invoking find declaration on Visible will you first bring to Visible in TForm. Then you can invoke Find Declaration again to jump to Visible in TCustomForm and again to jump to Visible in TControl.
 
  
Same is true for types like TColor.
+
&nbsp;&nbsp;&nbsp;Esto también ocurre para tipos cómo ''TColor''. Para el compilador es un simple ''longint''. Pero en los fuentes está definido cómo
For the compiler it is simply a 'longint'. But in the sources it is defined as
+
<syntaxhighlight lang=pascal> TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
+
  TColor = TGraphicsColor;</syntaxhighlight>
  TColor = TGraphicsColor;
 
  
And the same for '''forward defined classes''':
+
&nbsp;&nbsp;&nbsp;Y ocurre lo mismo con las clases definidas con antelación (''forward defined classes''):
For instance in TControl, there is a private variable
+
Por ejemplo en ''TControl'', está esta variable privada
FHostDockSite: TWinControl;
+
<syntaxhighlight lang=pascal> FHostDockSite: TWinControl;</syntaxhighlight>
Find declaration on TWinControl jumps to the forward definition
+
&nbsp;&nbsp;&nbsp;Buscar declaración sobre ''TWinControl'' saltará a la definición previa (''forward defined classe'')
TWinControl = class;
+
<syntaxhighlight lang=pascal> TWinControl = class;</syntaxhighlight>
And invoking it again jumps to the real implementation
+
&nbsp;&nbsp;&nbsp;Y haciéndolo de nuevo saltará a la implementación real
TWinControl = class(TControl)
+
<syntaxhighlight lang=pascal> TWinControl = class(TControl)</syntaxhighlight>
This way you can track down every identifier and find every overload.
+
&nbsp;&nbsp;&nbsp;De esta forma se puede seguir hasta el final la declaración de cada identificador y ver cada sobrecarga o redefinición del mismo.
  
'''Hints:''' You can jump back with Ctrl+H.
+
&nbsp;&nbsp;&nbsp;'''Sugerencia:''' Puedes regresar al punto anterior al salto con {{keypress|Ctrl}}+{{keypress|H}}.
  
==Identifier Completion==
+
==Completar Identificador==
"Identifier Completion" is invoked by Ctrl+Space. It shows all identifiers in scope. For example:
+
Completar Identificador se llama con {{keypress|Ctrl}}+{{keypress|Space}}. Se mostrarán todos los identifiacdores en el ámbito. Por ejemplo:
  
  procedure TForm1.FormCreate(Sender: TObject);
+
<syntaxhighlight lang=pascal> procedure TForm1.FormCreate(Sender: TObject);
 
   begin
 
   begin
 
     |
 
     |
   end;
+
   end;</syntaxhighlight>
  
Place the cursor between ''begin'' and ''end'' and press Ctrl+Space. The IDE/CodeTools will now parse all reachable code and present you a list of all found identifiers. The CodeTools cache the results, so invoking it a second time will be much faster.
+
Sitúa el cursor entre ''begin'' y ''end'' y pulsa {{keypress|Ctrl}}+{{keypress|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.
  
'''Note for Delphians:''' Delphi calls it ''Code completion''.
+
'''Nota para usuarios Delphi:''' En Delphi esto se denomina ''Completar Código''.
  
Some identifiers like 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' are built into the compiler and are not defined anywhere in source. The identifier completion has a lot of these things built in as well. If you find one missing, just create a feature request in the bug tracker.
+
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'')
  
Identifier completion does not complete '''keywords'''. So you can not use it to complete 'proc' to 'procedure'. For these things use Ctrl+W [[#Word Completion|Word Completion]] instead or Ctrl+J [[#Code Templates|Code Templates]].
+
Completar identificador no completa palabras del lenguaje. No puede ser utilizado para completar proc a procedura. Para hacer esto utiliza {{keypress|Ctrl}}+{{keypress|W}} [[#Completar palabra|Completar palabra]] y no {{keypress|Ctrl}}+{{keypress|J}} [[#Plantillas de código|Plantillas de código]].
  
Identifier completion shows even those identifiers, that are not compatible.
+
Completar identificador muestra incluso los identificadores que no son compatibles.
  
===Prefix===
+
===Prefijos===
You can start identifier completion in a word. Then the letters to the left will be taken as prefix. For example:
+
&nbsp;&nbsp;&nbsp;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:
  
  procedure TForm1.FormCreate(Sender: TObject);
+
<syntaxhighlight lang=pascal> procedure TForm1.FormCreate(Sender: TObject);
 
   begin
 
   begin
 
     Ca|ption
 
     Ca|ption
   end;
+
   end;</syntaxhighlight>
  
The box will show you only the identifiers beginning with 'Ca'.
+
&nbsp;&nbsp;&nbsp;Sólo se mostrarán los identificadores que comienzan por 'Ca'.
  
===Keys===
+
===Teclas===
  
* Letter or number: add the character to the source editor and the current prefix. This will update the list.
+
* Letra o numero: añade el carácter al código del editor y al prefijo. La lista se actualiza.
* Backspace: remove the last character from source editor and prefix. Updates the list.
+
* Borrar hacia atrás ({{keypress|Backspace}}): elimina el carácter código del editor y al prefijo. La lista se actualiza.
* Return: replace the whole word at cursor with the selected identifier and close the popup window.
+
* {{keypress|Intro}} / {{keypress|Enter}}: reemplaza la palabra completa bajo el cursor con el identificador seleccionado y cierra la lista.
* Shift+Return: as ''Return'', but replaces only the prefix (left part) of the word at the cursor.
+
* {{keypress|Shift}}+{{keypress|Enter}}: cómo {{keypress|Enter}}, pero reemplaza únicamente el prefijo (la parte izquierda) de la palabra bajo el cursor.
* Up/Down: move selection
+
* {{keypress|Up}} / {{keypress|Down}}: mueve la selección de identificador en la lista.
* Escape: close popup without change
+
* {{keypress|Escape}}: cierra la lista sin realizar cambios.
* Tab: completes the prefix to next choice. For example: The current prefix is 'But' and the identifier completion only shows 'Button1' and 'Button1Click'. Then pressing ''Tab'' will complete the prefix to 'Button1'.
+
* {{keypress|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 {{keypress|Tab}} el prefijo se completa a 'Button1'.
* Else: as ''Return'' and add the character to the source editor
+
* Otras teclas: realizan su cometido normal y cierran la lista si es necesario.
  
===Methods===
+
===Métodos===
  
When cursor is in a class definition and you identifier complete a method defined in an ancestor class the parameters and the override keyword. For example:
+
&nbsp;&nbsp;&nbsp;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:
  
<Delphi>
+
<syntaxhighlight lang=pascal> TMainForm = class(TForm)
TMainForm = class(TForm)
+
protected
protected
+
  mous|
  mous|
+
end;</syntaxhighlight>
end;
 
</DELPHI>
 
  
Completing '''MouseDown''' gives:
+
&nbsp;&nbsp;&nbsp;Completando con '''MouseDown''' obtendremos esto:
  
<Delphi>
+
<syntaxhighlight lang=pascal> TMainForm = class(TForm)
TMainForm = class(TForm)
+
protected
protected
 
 
   procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
 
   procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
 
         Y: Integer); override;
 
         Y: Integer); override;
end;
+
end;</syntaxhighlight>
</DELPHI>
+
 
 +
===Propiedades===
 +
 
 +
<syntaxhighlight lang=pascal> property MiEntero: integer read |;</syntaxhighlight>
 +
 
 +
&nbsp;&nbsp;&nbsp;Completar identificador mostrará en la lista '''''FMiEntero''''' y '''''GetMiEntero'''''.
 +
 
 +
<syntaxhighlight lang=pascal> property MiEntero: integer write |;</syntaxhighlight>
 +
 
 +
&nbsp;&nbsp;&nbsp;Completar identificador mostrará en la lista '''''FMiEntero''''' y '''''SetMiEntero'''''.
 +
 
 +
===Sección ''Uses'' / nombres de unidad===
 +
 
 +
&nbsp;&nbsp;&nbsp;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''').
 +
 
 +
===Sentencias===
 +
 
 +
<syntaxhighlight lang=pascal> procedure TMainForm.Button1Click(Sender: TObject);
 +
begin
 +
  ModalRe|;
 +
end;</syntaxhighlight>
 +
 
 +
&nbsp;&nbsp;&nbsp;se convierte en:
 +
 
 +
<syntaxhighlight lang=pascal> procedure TMainForm.Button1Click(Sender: TObject);
 +
begin
 +
  ModalResult:=|;
 +
end;</syntaxhighlight>
 +
 
 +
==Completar palabra==
 +
&nbsp;&nbsp;&nbsp;''Completar palabra'' se invoca con {{keypress|Ctlr}}+{{keypress|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''.
 +
 
 +
==Ir a directiva de inclusión==
 +
&nbsp;&nbsp;&nbsp;''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.
 +
 
 +
==Publicar Proyecto==
 +
&nbsp;&nbsp;&nbsp;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á.
 +
 
 +
&nbsp;&nbsp;&nbsp;Un directorio normal de proyecto contiene mucha información, pero no es necesario hacerla pública toda:
 +
 
 +
&nbsp;&nbsp;&nbsp; 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.
 +
 
 +
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).
 +
 
 +
&nbsp;&nbsp;&nbsp;Para crear un archivo .lpi únicamente con la información básica y con los fuentes, junto con los directorios necesarios utiliza ''Publicar Proyecto''.
 +
 
 +
&nbsp;&nbsp;&nbsp;'''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.
 +
 
 +
&nbsp;&nbsp;&nbsp;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.
 +
 
 +
==Sugerencias desde comentarios==
 +
 
 +
&nbsp;&nbsp;&nbsp;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.
 +
 
 +
&nbsp;&nbsp;&nbsp;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
 +
 
 +
===Comentarios mostrados en la sugerencia===
  
===Properties===
+
&nbsp;&nbsp;&nbsp;Comentarios precediendo a una declaración, sin línea vacía y que no empiezan con el signo '''<''':
  
<Delphi>
+
<syntaxhighlight lang=pascal> var
property MyInt: integer read |;
+
  {comentario}
</DELPHI>
+
  Identifier: integer;</syntaxhighlight>
  
Identifier completion will show '''FMyInt''' and '''GetMyInt'''.
+
&nbsp;&nbsp;&nbsp;Comentarios con el signo '''<''' pertenecen al identificador precedente.
  
<Delphi>
+
&nbsp;&nbsp;&nbsp;Comentarios detrás de un identificador en la misma línea:
property MyInt: integer write |;
 
</DELPHI>
 
  
Identifier completion will show '''FMyInt''' and '''SetMyInt'''.
+
<syntaxhighlight lang=pascal> var
 +
  identifier, // comentario
 +
  other,</syntaxhighlight>
  
===Uses section / Unit names===
+
&nbsp;&nbsp;&nbsp;Comentarios tras la definición en la misma línea:
  
In uses sections the identifier completion will show the filenames of all units in the search path. These will show all lowercase (e.g. '''avl_tree'''), because most units have lowercase filenames. On completion it will insert the nice case of the unit (e.g. '''AVL_Tree''').
+
<syntaxhighlight lang=pascal> var
 +
  identifier:
 +
    char; // comentario </syntaxhighlight>
  
===Statements===
+
&nbsp;&nbsp;&nbsp;Un ejemplo para el signo '''<''':
  
<DELPHI>
+
<syntaxhighlight lang=pascal> const
procedure TMainForm.Button1Click(Sender: TObject);
+
  a = 1;
begin
+
  //< comentario para a
   ModalRe|;
+
   b = 2;
end;
+
  // comentario para c
</DELPHI>
+
  c = 3;</syntaxhighlight>
  
becomes:
+
&nbsp;&nbsp;&nbsp;Los tres tipos de comentarios son compatibles:
 +
<syntaxhighlight lang=pascal> {Comentario}(*Comentario*)//Comentario
 +
  c = 1;</syntaxhighlight>
  
<DELPHI>
+
&nbsp;&nbsp;&nbsp;Los comentarios que empiezan con '''$''' y '''%''' son ignorados.
procedure TMainForm.Button1Click(Sender: TObject);
 
begin
 
  ModalResult:=|;
 
end;
 
</DELPHI>
 
  
==Word Completion==
+
===Comentarios que no se muestra en la sugerencia===
"Word Completion" is invoked by Ctrl+W. It shows all words of all currently open editors.
 
  
Otherwise works the same as identifier completion.
+
&nbsp;&nbsp;&nbsp;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:
  
==Goto Include Directive==
+
<syntaxhighlight lang=pascal> type
"Goto Include Directive" in the search menu of the IDE jumps to {$I filename} statement where the current include file is used.
+
  { TMyClass }
  
==Publish Project==
+
  TMyClass = class</syntaxhighlight>
Creates a copy of the whole project. If you want to send someone just the sources and compiler settings of your code, this function is your friend.
 
  
A normal project directory contains a lot of information. Most of it is not needed to be published:
+
&nbsp;&nbsp;&nbsp;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.
The .lpi file contains session information (like caret position and bookmarks of closed units) and the project directory contains a lot of .ppu, .o files and the executable.
 
To create a lpi file with only the base information and only the sources, along with all sub directories use "Publish Project".
 
  
'''Note''': Since version 0.9.13 there is a new ''Project Option'' that allows you to store session information in a seperate file from the normal .lpi file.  This new file ends with the .lps extension and only contains session information, which will leave you .lpi file much cleaner.
+
&nbsp;&nbsp;&nbsp;El siguiente comentario será mostrado para GL_TRUE, pero no para GL_FALSE:
  
In the dialog you can setup the exclude and include filter, and with the command after you can compress the output into one archive.
+
<syntaxhighlight lang=pascal>  // Boolean
 +
  GL_TRUE = 1;
 +
  GL_FALSE = 0;</syntaxhighlight>
  
 
==Contribuciones y cambios==
 
==Contribuciones y cambios==
Line 610: Line 688:
 
* Pequeños retoque sobre formato - 4/11/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Pequeños retoque sobre formato - 4/11/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Adición de la Tabla resumen de los atajos de las ''IdeTools'' - 12 July 2004 [[User:Kirkpatc]]
 
* Adición de la Tabla resumen de los atajos de las ''IdeTools'' - 12 July 2004 [[User:Kirkpatc]]
* Versión en castellano (español) [[User:Iskraelectrica | iskraelectrica (jldc)]] / junio de 2008.
+
* Versión en castellano (español) [[User:Iskraelectrica | iskraelectrica (jldc)]] / junio-julio de 2008.

Latest revision as of 02:52, 20 January 2022

Deutsch (de) English (en) español (es) suomi (fi) français (fr) 日本語 (ja) 한국어 (ko) Nederlands (nl) português (pt) русский (ru) slovenčina (sk) 中文(中国大陆)‎ (zh_CN)

Descripción general

   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).

   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.

Tabla resumen de los atajos

Buscar Declaración Ctrl+Click o Alt+ (Salta a la declaración de la variable)
Salto a Procedimiento Ctrl+ Shift+ (Salta entre la definición y el cuerpo de procedimientos y funciones)
Plantillas de Código Ctrl+J
Edición sincronizada Ctrl+J (cuándo hay texto seleccionado)
Completar Código Ctrl+ Shift+C (Completar Clase)
Completar Identificador Ctrl+space
Completar Palabra Ctrl+W
Sugerencia de Parámetros Ctrl+ Shift+space
Búsqueda incremental Ctrl+E

Salto a Procedimiento

   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+.

   Por ejemplo:

 interface
 procedure HacerAlgo; // declaración del procedimiento
  //...  
 implementation
  //...  
 procedure HacerAlgo; // Cuerpo del procedimiento 
 begin
  //...
 end;

   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+ se regresa al cuerpo, y el cursor se sitúa al principio de la primera línea trás el begin.

   Esto funciona con procedimientos y funciones, sean o no miembros de una clase.

   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).

   Por ejemplo una función con diferente lista de parámetros:

 interface
 
 function HacerAlgo(p: char); // declaración de la función
 
 implementation
   
 function HacerAlgo(p: string); // cuerpo de la función
 begin
 end;

   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.

   Por ejemplo:
   Remombramos 'HacerAlgo' a 'Hazlo':

 interface
 
 procedure Hazlo; // declaración del procedimiento
 
 implementation
 
 procedure HacerAlgo; // Cuerpo del procedimiento
 begin
 end;

   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.

Archivos de inclusión

   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.

  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.

  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.

   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.

   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.

   Este mecanismo tiene límites, por supuesto. Algunos archivos están incluidos dos o más veces, por ejemplo, $(LazarusDir)/lcl/include/winapih.inc.

   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. ;)

Plantillas de código

   Las Plantillas de código permiten convertir un identificador en un texto o en un fragmento de código.

   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....

  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

 TClass = class(TBase)
 private
 
 public
   constructor Create;
   destructor Destroy; override;
 end;

además el cursor de posicionará en 'TClass'.

   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.

  La plantilla que más tiempo nos ahorrará es 'b'+Ctrl+J para begin..end.

Sugerencia de Parámetros

   Sugerencia de Parámetros muestra una caja con la lista de posibles declaraciones con sus parámetros para el procedimiento o función actual.

   Por ejemplo:

 Canvas.FillRect(|);

   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.

Parameterhints1.png

   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.

Parameterhints2.png

   Consejo: Utiliza Completar Declaración de Variable para declarar las variables.

   Nota: El nombre del atajo es "Show code context" (Mostrar Contexto del Código).

Búsqueda incremental

   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.

  • Por ejemplo pulsa e buscará y resaltará todas las apariciones de 'e'.
  • Pulsa t buscará y resaltará todas las apariciones de 'et' y así sucesivamente.
  • Puede saltar a la siguiente con F3 (o Ctrl+e mientras se busca) y a la previa con Shift+F3.
  • ← Backspace elimina el último carácte
  • Enter detiene la búsqueda sin añadir una nueva línea en el editor.
  • 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.
  • Pegar: Ctrl+V adjuntará el texto del portapapeles al texto de búsqueda actuales (desde lazarus 0.9.27 r19824).

Sugerencia: Búsqueda rápida de un identificador con búsqueda incremental

  • Mueve el cursor del texto sobre el identificador (no selecciones nada)
  • Pulsa Ctrl+C. En el editor de código fuente se selecciona el identificador y se copia en el portapapeles
  • Pulsa Ctrl+E para iniciar la búsqueda incremental
  • Pulsa Ctrl+V para buscar el identificador (desde 0.9.27)
  • Usa F3 y Shift+F3 para ir rápidamente a siguiente / anterior.
  • Usa cualquier tecla (por ejemplo, el cursor hacia la izquierda o la derecha) para finalizar la búsqueda.

Edición sincronizada

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.

Edición sincronizada funciona en todas las palabras en un área seleccionada:

  • Selecciona un bloque de texto
  • 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.
  • 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)
  • Edita la palabra
  • pulsa Esc para terminar

Ver un ejemplo animado aquí

  • Nota: Ctrl+J también se utiliza para editar plantillas. Cambia su significado si hay seleccionado algo de texto.

Completar Código

   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.

   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".

   Completar código combina varias potentes funciones. Ejemplos:

   La función que se activa depende de la posición del cursor en el editor de código.

Completar Clase

   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.

   Por ejemplo: crea una clase (utiliza Platillas de código para ahorrarte trabajo de escritura):

 TEjemplo = class(TObject)
 public
   constructor Create;
   destructor Destroy; override;
 end;

   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:

 { TEjemplo }
 
 constructor TEjemplo.Create;
 begin
   |
 end;
 
 destructor TEjemplo.Destroy;
 begin
   inherited Destroy;
 end;

   Nota: El carácter '|' representa el cursor.

   Sugerencia: puedes saltar entre la definición y el cuerpo de un método con Ctrl+ Shift+.

   Cómo se puede ver, el IDE añade la llamada 'inherited Destroy' siempre que el método esté definido con override.

   Ahora añade un método HacerAlgo:

 TEjemplo = class(TObject)
 public
   constructor Create;
   procedure HacerAlgo(i: integer);
   destructor Destroy; override;
 end;

   Ahora se pulsa Ctrl+ Shift+C y el IDE añadirá

 procedure TEjemplo.HacerAlgo(i: integer);
 begin
   |
 end;

   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.

Completar Propiedades

   Añade la propiedad UnEntero:

 TEjemplo = class(TObject)
 public
   constructor Create;
   procedure HacerAlgo(i: integer);
   destructor Destroy; override;
   property UnEntero: Integer;
 end;

   Pulsa Ctrl+Shift+C y obtendrás esto:

 procedure TEjemplo.SetUnEntero(const AValue: integer);
 begin
   |if FUnEntero=AValue then exit;
   FUnEntero:=AValue;
 end;

   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+ para ver los cambio realizados en la clase:

 TEjemplo = class(TObject)
 private
   FUnEntero: integer;
   procedure SetUnEntero(const AValue: integer);
 public
   constructor Create;
   procedure HacerAlgo(i: integer);
   destructor Destroy; override;
   property UnEntero: integer read FUnEntero write SetUnEntero;
 end;

    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.

   Crear una propiedad de sólo lectura:

 property NombrePropiedad: TipoPropiedad read;

   Se expandirá a

 property NombrePropiedad: TipoPropiedad read FNombrePropiedad;

   Crear una propiedad de sólo escritura:

  property NombrePropiedad: TipoPropiedad write;

   Se expandirá a

 property NombrePropiedad: TipoPropiedad write SetNombrePropiedad;

   Crear una propiedad de sólo lectura con una función de lectura:

 property NombrePropiedad: TipoPropiedad read GetNombrePropiedad;

   La función GetNombrePropiedad será añadida:

 function GetNombrePropiedad: TipoPropiedad;

   Crear una propiedad con un modificador 'stored':

 property NombrePropiedad: TipoPropiedad stored;

   Se expandirá a

 property NombrePropiedad: TipoPropiedad read FNombrePropiedad write SetNombrePropiedad stored NombrePropiedadIsStored;

   Cómo stored se utiliza para el streaming los modificadores read y write se añaden automáticamente.

   Sugerencia: Completar identificador también reconoce propiedades incompletas, sugiriendo los nombres por defecto. Por ejemplo:

 property NombrePropiedad: TipoPropiedad read |;

   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'.

Completar Procedimiento declarado

   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.

   Por ejeamplo:    Añade un nuevo procedimiento en la sección interface:

 procedure HacerAlgo;

   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:

 procedure HacerAlgo;
 begin
   |
 end;

   Nota: puedes saltar alternativamente entre el cuerpo del procedimiento y su definición pulsando Ctrl+ Shift+.

   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:

  procedure Proc1;
  procedure Proc2; // nuevo procedimiento
  procedure Proc3;

   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.

   Varios procedimientos:

 procedure Proc1_Viejo; // el cuerpo existe
 procedure Proc2_Nuevo; // el cuerpo No existe
 procedure Proc3_Nuevo; //  "
 procedure Proc4_Nuevo; //  "
 procedure Proc5_Existente; // el cuerpo existe

   Completar código añadirá los cuerpos de los tres procedimientos(Proc2_Nuevo, Proc3_Nuevo, Proc4_Nuevo).

   ¿Porqué se llama Forward Procedure Completion?

   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.

Completar asignación de eventos

   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.

   Por ejemplo:    En un método, el evento FormCreate mismamente, añade la línea 'OnPaint:=':

 procedure TForm1.Form1Create(Sender: TObject);
 begin
   OnPaint:=|
 end;

   El caracter '|' representa el cursor y no hay que escribirlo. Pulsa Ctrl+Shift+C para completar el código. La sentencia se completará con

 OnPaint:=@Form1Paint;

   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:

 procedure TForm1.Form1Paint(Sender: TObject);
 begin
   |
 end;

   El comportamiento es el mismo que cuándo en el inspector de objetos añadimos código para un evento de un objeto.

   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.

   Sugerencia: nosotros podemos definir el nombre del método, por ejemplo:

 OnPaint:=@ElMetodoParaPintar;

   Para ello hay que situar el cursor sobre el nombre del método antes de llamar a completar código con Ctrl+ Shift+C.

Completar Declaración de Variable

   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.

   Por ejemplo:

 procedure TForm1.Form1Create(Sender: TObject);
 begin
  i:=3;
 end;

    Sitúa el cursor en la 'i' o justo detrás. Púlsa Ctrl+ Shift+C para completar el código y se obtiene:

 procedure TForm1.Form1Create(Sender: TObject);
 var
  i: Integer;
 begin
  i:=3;
 end;

   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.

   Otro ejemplo:

 type
  TDonde = (Final, Mitad, Principio);
 
  procedure TForm1.Form1Create(Sender: TObject);
  var
    a: array[TDonde] of char;
  begin
    for Donde:=Low(a) to High(a) do writeln(a[Donde]);
  end;

   Sitúa el cursor en 'Donde' y pulsa Ctrl+ Shift+C, obtendrás:

 procedure TForm1.Form1Create(Sender: TObject);
  var
    a: array[TDonde] of char;
    Donde: TDonde;
  begin
    for Donde:=Low(a) to High(a) do writeln(a[Donde]);
  end;

   Desde la versión 0.9.11 Lazarus también completa parámetros. Por ejemplo

 procedure TForm1.FormPaint(Sender: TObject);
  begin
    with Canvas do begin
      Line(x1,y1,x2,y2);
    end;
  end;

   Sitúa el cursor en 'x1' y pulsa Ctrl+ Shift+C, obtendrás:

 procedure TForm1.FormPaint(Sender: TObject);
  var
    x1: integer;
  begin
    with Canvas do begin
      Line(x1,y1,x2,y2);
    end;
  end;

Completar Llamada a procedimiento

   Nota de traductor: lo que sigue no funciona, si lo intentamos no hace nada.

   Completar código creará un nuevo procedimiento desde la orden de invocación.

   Supongamos que acabas de escribir la orden HacerAlgo(Ancho);

 procedure UnProcedimiento;
 var
  Ancho: integer;
 begin
  Ancho:=3;
  HacerAlgo(Ancho);
 end;

   Coloca el cursor sobre el identificador "HacerAlgo" y pulsa Ctrl+ Shift+C para obtener:

 procedure HacerAlgo(aWidth: LongInt);
 begin

 end;

 procedure UnProcedimiento;
  var
   Width: integer;
 begin
  Width:=3;
  HacerAlgo(Width);
 end;

Completar Clase inversa

   "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 ....

   Esta función está disponible desde la versión 0.9.21 de Lazarus.

   Por ejemplo:

  procedure TForm1.HacerAlgo(Emisor: TObject);
  begin
  end;

   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.

   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.

Comentarios y Completar código

   Completar código procura mantener los comentarios donde corresponde.

   Por ejemplo:

  FLista: TList; // lista de TComponent
  FEntero: integer;

   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

  FLista: TList; { lista de TComponent
    Este es un comentario de varias líneas, comienza
    en la línea FLista, a la que la utilidad considera
    que pertenece y no romperá esta ligazón.
    El código se inserta después del comentario.}
  FEntero: integer;

   Si el comentario comienza en la línea siguiente, será tratado como perteneciente al código que le sigue. Por ejemplo:

  FLista: TList; // lista de TComponent
    { Este comentario está ligado a la sentencia precedente. 
      El nuevo código será insertado delante del comentario
      a continuación del comentario de la línea de FLista. }
  FEntero: integer;

Refactorización (Refactoring)

Invertir Asignaciones

   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.

   Ejemplo:

 procedure HacerAlgo;
 begin
  AValueUnoStudio := BValorUno;
  AValorDos := BValorDos;
  AValorTres  := BValorTres;
 end;

   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:

 procedure HacerAlgo;
 begin
  BValorUno  := AValueUnoStudio;
  BValorDos  := AValorDos;
  BValorTres := AValorTres;
 end;

Encerrar Selección

   Selecciona un blouqe de texto e invócala, con el menú contextual (Refactoring -> Encerrar Selección), por ejemplo. En el 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.

Renombrar Identificador

   Sitúa el cursor sobre un identificador y llámalo. Aparece un diálogo en el que podemos configurar el ámbito de la búsqueda y el nuevo nombre.

  • Se renombra´na todas las ocurrencias que utilicen esta declaración. No lo hará con otras declaraciones con el mismo nombre.
  • Primero comprueba los posibles conflictos de nombre.
  • Límites: Únicamente funciona con código pascal, no cambia el nombre a archivos y no modifica archivos lfm/lrs ni archivos lazdoc.

Buscar referencias a identificador

Sitúa el cursor sobre un identificador y llámalo (menú Buscar -> Buscar referencias a identificador...), aparece un 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.

Mostrar métodos abstractos

   Esta utilidad lista y crea el esquema de métodos virtuales y abstractos que necesitan ser implementados.

   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.

Extraer Procedimientos

   Ver Extraer Procedimientos

Buscar Declaración

   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

   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.

   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:

   La propiedad Visible está definida en primer lugar en TControl (controls.pp), está redefinida en TCustomForm y por último en TForm.

   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.

   Esto también ocurre para tipos cómo TColor. Para el compilador es un simple longint. Pero en los fuentes está definido cómo

 TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 TColor = TGraphicsColor;

   Y ocurre lo mismo con las clases definidas con antelación (forward defined classes): Por ejemplo en TControl, está esta variable privada

 FHostDockSite: TWinControl;

   Buscar declaración sobre TWinControl saltará a la definición previa (forward defined classe)

 TWinControl = class;

   Y haciéndolo de nuevo saltará a la implementación real

 TWinControl = class(TControl)

   De esta forma se puede seguir hasta el final la declaración de cada identificador y ver cada sobrecarga o redefinición del mismo.

   Sugerencia: Puedes regresar al punto anterior al salto con Ctrl+H.

Completar Identificador

Completar Identificador se llama con Ctrl+Space. Se mostrarán todos los identifiacdores en el ámbito. Por ejemplo:

 procedure TForm1.FormCreate(Sender: TObject);
  begin
    |
  end;

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.

Nota para usuarios Delphi: En Delphi esto se denomina Completar Código.

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)

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.

Completar identificador muestra incluso los identificadores que no son compatibles.

Prefijos

   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:

 procedure TForm1.FormCreate(Sender: TObject);
  begin
    Ca|ption
  end;

   Sólo se mostrarán los identificadores que comienzan por 'Ca'.

Teclas

  • Letra o numero: añade el carácter al código del editor y al prefijo. La lista se actualiza.
  • Borrar hacia atrás (← Backspace): elimina el carácter código del editor y al prefijo. La lista se actualiza.
  • Intro / Enter: reemplaza la palabra completa bajo el cursor con el identificador seleccionado y cierra la lista.
  • Shift+ Enter: cómo Enter, pero reemplaza únicamente el prefijo (la parte izquierda) de la palabra bajo el cursor.
  • / : mueve la selección de identificador en la lista.
  • Escape: cierra la lista sin realizar cambios.
  • 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'.
  • Otras teclas: realizan su cometido normal y cierran la lista si es necesario.

Métodos

   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:

 TMainForm = class(TForm)
 protected
   mous|
 end;

   Completando con MouseDown obtendremos esto:

 TMainForm = class(TForm)
 protected
  procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
         Y: Integer); override;
 end;

Propiedades

 property MiEntero: integer read |;

   Completar identificador mostrará en la lista FMiEntero y GetMiEntero.

 property MiEntero: integer write |;

   Completar identificador mostrará en la lista FMiEntero y SetMiEntero.

Sección Uses / nombres de unidad

   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).

Sentencias

 procedure TMainForm.Button1Click(Sender: TObject);
 begin
   ModalRe|;
 end;

   se convierte en:

 procedure TMainForm.Button1Click(Sender: TObject);
 begin
   ModalResult:=|;
 end;

Completar palabra

   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.

Ir a directiva de inclusión

   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.

Publicar Proyecto

   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á.

   Un directorio normal de proyecto contiene mucha información, pero no es necesario hacerla pública toda:

    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.

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).

   Para crear un archivo .lpi únicamente con la información básica y con los fuentes, junto con los directorios necesarios utiliza Publicar Proyecto.

   Nota: Desde la versión 0.9.13 existe una nueva Opciones de proyecto 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.

   En el 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.

Sugerencias desde comentarios

   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.

   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

Comentarios mostrados en la sugerencia

   Comentarios precediendo a una declaración, sin línea vacía y que no empiezan con el signo <:

 var
  {comentario}
  Identifier: integer;

   Comentarios con el signo < pertenecen al identificador precedente.

   Comentarios detrás de un identificador en la misma línea:

 var 
  identifier, // comentario 
  other,

   Comentarios tras la definición en la misma línea:

 var
  identifier: 
    char; // comentario

   Un ejemplo para el signo <:

 const
  a = 1;
  //< comentario para a
  b = 2;
  // comentario para c
  c = 3;

   Los tres tipos de comentarios son compatibles:

 {Comentario}(*Comentario*)//Comentario
  c = 1;

   Los comentarios que empiezan con $ y % son ignorados.

Comentarios que no se muestra en la sugerencia

   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:

 type
  { TMyClass }

  TMyClass = class

   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.

   El siguiente comentario será mostrado para GL_TRUE, pero no para GL_FALSE:

   // Boolean
  GL_TRUE = 1;
  GL_FALSE = 0;

Contribuciones y cambios

   Esta página ha sido convertida desde la versión de epikwiki.

  • Creación de la página y plantilla original - 4/6/2004 VlxAdmin
  • Nuevo contenido inicial - 4/10/2004 MattiasG
  • Pequeños retoque sobre formato - 4/11/2004 VlxAdmin
  • Adición de la Tabla resumen de los atajos de las IdeTools - 12 July 2004 User:Kirkpatc
  • Versión en castellano (español) iskraelectrica (jldc) / junio-julio de 2008.