Los componentes son las piedra angular de la programación en Delphi. Aunque la mayoría de los componentes representan partes visibles de la interfaz de usuario, existen también componentes no visuales, como por el ejemplo los objetos Timer y Database.

Un componente, en su definición más simple no es más que un objeto descendiente del tipo TComponent. Todos los componentes descienden en su forma más primitiva de TComponent, ya que TComponent proporciona las características básicas que todo componente debe tener: capacidad de ser mostrado en la paleta de componentes así como de operar a nivel de diseño de formulario.

Los componentes hacen fácil la programación en Delphi. En vez de tener que operar a nivel de unidades, el usuario de un componente simplemente tiene que pinchar en él y situarlo en la posición deseada de su form. Eso es todo: Delphi se encarga de lo demás.

Todos los componentes forman parte de la jerarquía de objetos denominada Visual Component Library (VCL). Cuando se crea un nuevo componente, este se deriva a partir de un componente existente (bien sea TComponent o algún otro más especializado) y se añade a la VCL.

Como ya se ha mencionado un componente es un objeto, y como tal, consta de código y datos. Pero al referirnos a estos no utilizaremos estos terminos, sino que hablaremos de propiedades y métodos, así como de eventos. A lo largo de este curso iremos estudiando en profundidad todos estos aspectos, pero hagamos ahora una primera aproximación:

• Propiedades

  Las propiedades proporcionan al usuario del componente un fácil acceso al mismo. Al mismo tiempo, permite al programador del componente "esconder" la estructura de datos subyacente. Entre las ventajas de utilizar propiedades para acceder al componente se pueden citar:

  • Las propiedades están disponibles en tiempo de diseño. De este modo el usuario del componente puede inicializar los valores de las propiedades sin necesidad de escribir una sóla línea de código.
  • Las propiedades permiten la validación de los datos al mismo tiempo de ser introducidas. Así se pueden prevenir errores causados por valores inválidos.
  • Nos aseguran que desde el primer momento nuestras propiedades tendrán un valor válido, evitando el error común de hacer referencia a una variable que no ha sido convenientemente inicializada.
  
  
• Eventos

  Los eventos son las conexiones existentes entre un determinado suceso y el código escrito por el programador de componentes. Asi por ejemplo, ante el suceso clic del ratón se podría mostrar un mensaje en pantalla. Al código que se ejecuta cuando se produce un determinado evento se le denomina manejador de eventos (event handler) y normalmente es el propio usuario del componente quién lo escribe. Los eventos má comúnes ya forman parte de los propios componentes de Delphi (acciones del ratón, pulsaciones de teclado...), pero es también posible definir nuevos eventos.

• Métodos

  Los métodos son los procedimientos y/o funciones que forman parte del componente. El usuario del componente los utiliza para realizar una determinada acción o para obtener un valor determinado al que no se puede acceder por medio de una propiedad. Ya que requieren ejecución de código, los métodos sólo están disponibles en tiempo de ejecución.

1. Crear una unidad para el nuevo componente.
2. Derivar el nuevo componente a partir de otro existente, el cuál servirá de base para añadir las nuevas características deseadas.
3. Añadir las propiedades, eventos y métodos necesarios al nuevo componente.
4. Registrar el componente, incluyendo los bitmaps adicionales, ficheros de ayuda, etc.
5. Instalar el nuevo componente en la paleta de componentes.

De todos los pasos citados, hay uno que es especialmente importente: la elección del ascendiente a partir del cuál derivar el nuevo componente. Este paso es crucial, ya que una buena elección del ascendiente puede hacernos la tarea de añadir nuevas propiedades y métodos realmente fácil, mientras que una mala elección puede hacernos imposible llegar al objetivo propuesto.

• TComponent - El punto de partida para los componentes no visuales.
• TWinControl - El punto de partida si es necesario que el componente disponga de handles.
• TGraphicControl - Un buen punto de partida para componentes visuales que no sea necesario que dispongan de handles, es decir, que no reciban el foco. Esta clase dispone del método Paint y de Canvas.
• TCustomControl - El punto de partida más común. Esta clase dispone de window handle, eventos y propiedades comúnes y, principalmente, canvas con el método Paint.

Bien, ya sabemos como determinar el punto de partida. Veamos ahora como crear la unidad que albergará el componente. Hay dos opciones, crear la unidad manualmente o dejar que Delphi haga el trabajo "sucio" utilizando el experto de componentes. Si optamos por la primera solución, basta con hacer clic en new unit y ponernos manos a la obra, pero de este modo tendremos que hacer todo a mano: derivar el nuevo componente, registrarlo, etc. Por ello es más recomendable la segunda opción: utilizar el experto de componentes.

Para abrir el experto de componentes basta con elegir File|New Component.

• Class Name: Aquí debemos especificar el nombre del nuevo componente.
• Ancestor type: Introduciremos aquí el ascendiente a partir del cuál derivaremos nuestro componente.
• Palette Page: Indicaremos aquí la página de la paleta en la cuál queremos que aparezca el nuevo componente.

Una vez introducidos estos campos, al pulsar sobre OK se nos desplegará el código de nuestra unidad. Si por ejemplo hemos introducido los siguientes datos en el experto de componentes:

Al hacer clic en aceptar, Delphi nos generaría la siguiente unidad, lista para introducir las propiedades y métodos de nuestro componente:

unit Unit1;

interface

uses
  SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
  Forms, Dialogs;

type
  TMiComponente = class(TComponent)
  private
    { Private declarations }
  protected
    { Protected declarations }
  public
    { Public declarations }
  published
    { Published declarations }
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Curso', [TMiComponente]);
end;

end.
 

A partir de aquí todo consiste en introducir las propiedades y métodos necesarios para el funcionamiento de nuestro componente. Pero antes de nada conviene hacer notar algunos aspectos:

En la clausula uses, Delphi añade por defecto las unidades estandard. Si nuestro componente no usa alguna de ellas podemos eliminarla de dicha clausula. Del mismo modo, si utilizamos algún procedimiento o función situado en otra unidad, debemos añadir dicha unidad a la clausula uses. Vamos, como siempre ¿no? ;)

Las declaraciones de las propiedades, campos y métodos que vayamos definiendo, las situaremos en la sección apropiada de interfaz según corresponda, es decir las declararemos privadas, protegidas, pública o publicadas.

Delphi declara y define automaticamente el procedimiento register para registrar el componente en la paleta.