Difference between revisions of "Lazarus IDE Tools/es"

From Lazarus wiki
Jump to navigationJump to search
Line 444: Line 444:
  
 
==Find Declaration==
 
==Find Declaration==
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.
+
   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.
  
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.
+
   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ú princiapl: Buscar -> Saltar atrás o Ctrl+H.
  
There are some differences to Delphi:
+
Existen algunas diferencias con Delphi:
 
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 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:
  

Revision as of 21:33, 6 July 2008

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+Up (Salta a la declaración de la variable)
Salto a Procedimiento Ctrl+Shift+Up (Salta entre la definición y el cuerpo de procedimientos y funciones)
Plantillas de Código Ctrl+J
Completar Código Ctrl+Shift+C (Completar Clase)
Completar Identificador Ctrl+Space
Completar Palabra Ctrl+W
Sugerencia de Parámetros Ctrl+Shift+Space

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.

   Por ejemplo: <delphi> interface

procedure HacerAlgo; // declaración del procedimiento
 //...  
implementation
 //...  
procedure HacerAlgo; // Cuerpo del procedimiento 
begin
 //...
end;</delphi>

   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.

   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: <delphi> interface

function HacerAlgo(p: char); // declaración de la función

implementation
  
function HacerAlgo(p: string); // cuerpo de la función
begin
end;</delphi> 

   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': <delphi> interface

procedure Hazlo; // declaración del procedimiento

implementation

procedure HacerAlgo; // Cuerpo del procedimiento
begin
end;</delphi>

   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 <delphi> T = class(T)

private

public
  constructor Create;
  destructor Destroy; override;
end;</delphi>

además el cursor de posicionará detrás de la primera 'T'.

   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:

<delphi> Canvas.FillRect(|);</delphi>

   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 distintas declaraciones de FillRect.

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:

  • Completar Clase (Class Completion): completa propiedades, añade cuerpos de métodos, añade variables y métodos privados.
  • Completar procedimiento (Forward Procedure Completion): añade cuerpos de procedimientos.
  • 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.
  • Completar declaración de variables (Variable Declaration Completion): añade la declaración de variables locales.
  • Completar llamada a procedimiento (Procedure Call Completion): añade un nuevo procedimiento.
  • Completar procedimiento inverso (Reversed procedure completion): añade la definición de cuerpos para procedimientos y funciones.
  • Completar clase inversa (Reversed class completion): añade declaraciones para cuerpos de métodos.

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

<delphi> TEjemplo = class(TObject)

public
  constructor Create;
  destructor Destroy; override;
end;</delphi>

   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:

<delphi> { TEjemplo }

constructor TEjemplo.Create;
begin
  |
end;

destructor TEjemplo.Destroy;
begin
  inherited Destroy;
end;</delphi>

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

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

   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:

<delphi> TEjemplo = class(TObject)

public
  constructor Create;
  procedure HacerAlgo(i: integer);
  destructor Destroy; override;
end;</delphi>

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

<delphi> procedure TEjemplo.HacerAlgo(i: integer);

begin
  |
end;</delphi>

   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: <delphi> TEjemplo = class(TObject)

public
  constructor Create;
  procedure HacerAlgo(i: integer);
  destructor Destroy; override;
  property UnEntero: Integer;
end;</delphi>

   Pulsa Ctrl+Shift+C y obtendrás esto: <delphi> procedure TEjemplo.SetUnEntero(const AValue: integer);

begin
  |if FUnEntero=AValue then exit;
  FUnEntero:=AValue;
end;</delphi>

   Completar código ha añadido el procedimiento de acceso de escritura a la propiedad (Write) y añadido al mismo el código más común. Ve a la definción de la clase con Ctrl+Shift+Up para ver los cambio realizados en la clase: <delphi> 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;</delphi>

    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: <delphi> property NombrePropiedad: TipoPropiedad read;</delphi>    Se expandirá a <delphi> property NombrePropiedad: TipoPropiedad read FNombrePropiedad;</delphi>    Crear una propiedad de sólo escritura: <delphi> property NombrePropiedad: TipoPropiedad write;</delphi>    Se expandirá a <delphi> property NombrePropiedad: TipoPropiedad write SetNombrePropiedad;</delphi>    Crear una propiedad de sólo lectura con una función de lectura: <delphi> property NombrePropiedad: TipoPropiedad read GetNombrePropiedad;</delphi>    La función GetNombrePropiedad será añadida: <delphi> function GetNombrePropiedad: TipoPropiedad;</delphi>    Crear una propiedad con un modificador 'stored': <delphi> property NombrePropiedad: TipoPropiedad stored;</delphi>    Se expandirá a <delphi> property NombrePropiedad: TipoPropiedad read FNombrePropiedad write SetNombrePropiedad stored NombrePropiedadIsStored;</delphi>    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: <delphi> property NombrePropiedad: TipoPropiedad read |;</delphi>    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: <delphi> procedure HacerAlgo;</delphi>    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: <delphi> procedure HacerAlgo;

begin
  |
end;</delphi>

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

   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: <delphi> procedure Proc1;

 procedure Proc2; // nuevo procedimiento
 procedure Proc3;</delphi>

   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: <delphi> 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</delphi>

   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:=': <delphi> procedure TForm1.Form1Create(Sender: TObject);

begin
  OnPaint:=|
end;</delphi>

   El caracter '|' representa el cursor y no hay que escribirlo. Pulsa Ctrl+Shift+C para completar el código. La sentencia se completará con <delphi> OnPaint:=@Form1Paint;</delphi>    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: <delphi> procedure TForm1.Form1Paint(Sender: TObject);

begin
  |
end;</delphi>

   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: <delphi> OnPaint:=@ElMetodoParaPintar;</delphi>    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: <delphi> procedure TForm1.Form1Create(Sender: TObject);

begin
 i:=3;
end;</delphi>

    Sitúa el cursor en la 'i' o justo detrás. Púlsa Ctrl+Shift+C para completar el código y se obtiene: <delphi> procedure TForm1.Form1Create(Sender: TObject);

var
 i: Integer;
begin
 i:=3;
end;</delphi>

   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: <delphi> 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;</delphi>

   Sitúa el cursor en 'Donde' y pulsa Ctrl+Shift+C, obtendrás: <delphi> 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;</delphi>

   Desde la versión 0.9.11 Lazarus también completa parámetros. Por ejemplo <delphi> procedure TForm1.FormPaint(Sender: TObject);

 begin
   with Canvas do begin
     Line(x1,y1,x2,y2);
   end;
 end;</delphi>

   Sitúa el cursor en 'x1' y pulsa Ctrl+Shift+C, obtendrás: <delphi> procedure TForm1.FormPaint(Sender: TObject);

 var
   x1: integer;
 begin
   with Canvas do begin
     Line(x1,y1,x2,y2);
   end;
 end;</delphi>

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); <delphi> procedure UnProcedimiento;

var
 Ancho: integer;
begin
 Ancho:=3;
 HacerAlgo(Ancho);
end;</delphi>

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

<delphi> procedure HacerAlgo(aWidth: LongInt);

begin
end;
procedure UnProcedimiento;
 var
  Width: integer;
begin
 Width:=3;
 HacerAlgo(Width);
end;</delphi>

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: <delphi> procedure TForm1.HacerAlgo(Emisor: TObject);

 begin
 end;</delphi>

   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: <delphi> FLista: TList; // lista de TComponent

 FEntero: integer;</delphi>

   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 <delphi> 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;</delphi>

   Si el comentario comienza en la línea siguiente, será tratado como perteneciente al código que le sigue. Por ejemplo: <delphi> 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;</delphi>

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:
<delphi> procedure HacerAlgo;

begin
 AValueUnoStudio := BValorUno;
 AValorDos := BValorDos;
 AValorTres  := BValorTres;
end;</delphi>

   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: <delphi> procedure HacerAlgo;

begin
 BValorUno  := AValueUnoStudio;
 BValorDos  := AValorDos;
 BValorTres := AValorTres;
end;</delphi>

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

Find Declaration

   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.

   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ú princiapl: Buscar -> Saltar atrás o Ctrl+H.

Existen algunas diferencias con Delphi: 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. 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. For the compiler it is simply a 'longint'. But in the sources it is defined as

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

And the same for forward defined classes: For instance in TControl, there is a private variable

FHostDockSite: TWinControl;

Find declaration on TWinControl jumps to the forward definition

TWinControl = class;

And invoking it again jumps to the real implementation

TWinControl = class(TControl)

This way you can track down every identifier and find every overload.

Hints: You can jump back with Ctrl+H.

Completar Identificador

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

<delphi> procedure TForm1.FormCreate(Sender: TObject);

 begin
   |
 end;</delphi>

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:

<delphi> procedure TForm1.FormCreate(Sender: TObject);

 begin
   Ca|ption
 end;</delphi>

   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 / Return: reemplaza la palabra completa bajo el cursor con el identificador seleccionado y cierra la lista.
  • Shift+Return: cómo Return, pero reemplaza únicamente el prefijo (la parte izquierda) de la palabra bajo el cursor.
  • Up/Down: mueve ela 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:

<delphi> TMainForm = class(TForm)

protected
  mous|
end;

</delphi>

   Completando con MouseDown obtendremos esto:

<delphi> TMainForm = class(TForm) protected

 procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
        Y: Integer); override;

end;</delphi>

Propiedades

<delphi> property MiEntero: integer read |;</delphi>

   Completar identificador mostrará en la lista FMiEntero y GetMiEntero.

<delphi> property MiEntero: integer write |;</delphi>

   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

<delphi> procedure TMainForm.Button1Click(Sender: TObject);

begin
  ModalRe|;
end;</delphi>

   se convierte en:

<delphi> procedure TMainForm.Button1Click(Sender: TObject);

begin
  ModalResult:=|;
end;</delphi>

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.


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

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.