Nuestro propósito es crear un componente idéntico al tipo TLabel (etiqueta), pero con una capacidad añadida: el parpadeo. Es decir, nuestro componente nos debe mostrar el mensaje introducido en la propiedad caption parpadeando con una determinada frecuencia. Además, si la frecuencia de parpadeo introducida es nula, el mensaje debe permanecer fijo en la pantalla (emulando lo que sucede con una etiqueta normal).

Como acabamos de decir, nuestro componente debe parpadear con una cierta frecuencia. Para ello necesitamos poder medir el tiempo que debe transcurrir entre el encendido y apagado del mensaje. Afortunadamente, Delphi nos proporciona un objeto que se amolda perfectamente a nuestros requisitos de medición de tiempo: TTimer.

Aunque no es este el lugar donde explicar las características del objeto Timer (la información básica de este componente se puede encontrar en la propia ayuda en línea de Delphi), conviene detenernos un instante en la propiedad del timer que vamos a utilizar: la propiedad interval. Esta propiedad nos permite especificar el intervalo de tiempo que queremos medir (en milisegundos). Cuando se alcanza el valor establecido se ejecuta el método especificado en el evento OnTimer.

El método que nosotros especificaremos para el evento OnTimer se encargará de visualizar y ocultar alternativamente el mensaje.

La teoría está muy bien, pero... ¿cómo añadimos el objeto timer a nuestro componente? En tiempo de diseño es sencillo. Basta con seleccionar el timer en la paleta de componentes y situarlo en nuestro form.

Pero al escribir un componente no podemos utilizar este sistema, si no que debemos hacerlo a mano. Los pasos generales que se deben seguir son los siguientes:

• Añadir la unidad en que se define el componente a la claúsula uses de nuestra unidad. En nuestro caso, como el objeto timer se declara en la unidad ExtCtrls, es esta unidad la que debemos añadir a la claúsula uses.
• Añadir al método create de nuestro componente el código necesario para construir el objeto (en nuestro caso, el timer).
• Escribir el código necesario para destruir el objeto en el método destroy de nuestro componente.

En la siguiente sección profundizaremos en estos dos últimos pasos.

Constructores

Los objetos que declaramos en un componente no existen en memoria hasta que el objeto es creado (también se dice que se crea una instancia del objeto) por una llamada al método constructor del objeto.

Un constructor no es más que un método que proporciona memoria para el objeto y apunta (mediante un puntero) hacia él. Llamando al método create, el constructor asigna la instancia del objeto a una variable.

Conviene hacer notar que todos los componentes heredan un método denominado create que se encarga de "crear" (en el sentido que acabamos de ver) el componente en memoria. De forma adicional, en el método create se pueden inicializar los valores de determinados campos del componente (comúnmente asignarles un valor por defecto)

En el método create del componente podemos crear objetos adicionales que necesite nuestro componente. En nuestro caso, en el método create de TBlinkLbl crearemos el timer.

Destructores

Cuando terminamos de utilizar un objeto, debemos destruirlo, es decir, liberar la memoria que ocupaba el objeto. Esta operación se realiza mediante el método destroy que todos los componentes heredan de TComponent.

Si hemos creado algún objeto adicional, también debemos destruirlo escribiendo el código necesario en el método destroy.

Delphi crea y destruye automaticamente nuestro componente cuando es necesario, ya que como se ha dicho, los métodos create y destroy se heredan de TComponent.

Pero si queremos utilizar algún objeto en nuestro componente, Delphi no lo crea y destruye automaticamente, sino que debemos hacerlo nosotros de forma manual. Este proceso se realiza añadiendo el código necesario a los métodos create y destroy. Es importante notar que nos se escriben los métodos de nuevo, sino que se sobrecargan con el nuevo código.

De una forma general esto se hace de la siguiente forma: (un ejemplo más concreto lo tenemos en el propio código fuente del componente)

• En la parte pública de nuestro componente declaramos los métodos create y destroy seguidos de la palabra clave overrride:

                public
                    constructor create(AOwner : TComponent); override;
                    destructor   destroy; override;
  

• Escribir el código adicional del constructor y del destructor en la sección de implementación.

                  constructor TComponent.Create(AOwner : TComponent);
                  begin
                       inherited Create(AOwner);
                       ...
                  end;
  
                  destructor TComponent.Destroy;
                  begin
                       ...
                       inherited destroy;
                  end;
  

  Lo más importante a tener en cuenta es que al sobrecargar un constructor, lo primero que se debe hacer es hacer una llamada al constructor original (línea inherited Create). A continuación se puede añadir el código necesario para crear el objeto.

  De un modo similar, al sobrecargar un destructor, primero se debe liberar el objeto que hayamos creado anteriormente y la última línea debe de ser una llamada al destructor original.

En nuestro proceso de diseño del componente nos queda aún un paso importante: cómo hacer que el mensaje parpadee. Hemos dicho que cuando se produzca el evento OnTimer se ejecutará el método parpadea que se encargará de visualizar y ocultar el mensaje, es decir, de producir el parpadeo.

La solución es muy simple, ya que nuestro componente, al descender de TLabel incorporá una propiedad que determina si el componente debe estar visible o no. Esta propiedad se denomina visible.

De este modo, nuestro método parpadea lo único que hará será alternar el valor de la propiedad booleana visible según se produzca el evento OnTimer. Los detalles concretos de implementación se muestran en el código fuente.

Para que el diseño del componente este finalizado nos quedan por ver dos aspectos:

• Hemos comentado que si el valor introducido como frecuencia de parpadeo es nulo, el mensaje debe permanecer fijo en pantalla. Esto se logra activando y desactivando el componente cuando se introduce el valor de la propiedad velocidad en el inspector de objetos (ver el procedimiento SetVelocidad en el código fuente).
  De este modo, si se introduce 0 como valor de la velocidad, simplemente se deshabilita el timer y se pone el valor de la propiedad visible a True. Si el valor introducido es distinto de cero, se habilita el timer y, por consiguiente, el parpadeo.
  
  
• Un último detalle es dar un valor por defecto a la propiedad velocidad de parpadeo. Esto se consigue en dos pasos: primeramente en la declaración de la propiedad velocidad se añade la palabra clave default seguida del valor por defecto (400 en nuestro caso). A continuación, en el constructor se inicializa el campo asociado con la propiedad (FVelocidad:=400). Los dos pasos son necesarios, no pudiendose obviar ninguno de los dos.
  Este detalle de asignar valores por defecto es más importante de lo que parece a simple vista, ya que de este modo nos evitamos errores de inicialización, asegurándonos que la propiedad siempre tendrá (incluso desde el principio) un valor válido. Adicionalmente, en los forms en que se utilice el componente, Delphi sólo guardará el valor de la propiedad si difiere de su valor por defecto.

unit Blinklbl;      { (c)1996 by Luis Roche }

interface

uses
  Classes, StdCtrls, ExtCtrls;    { TTimer se declara en ExtCtrls }

type
  TBlinkLabel = class(TLabel)    {TBlinkLabel deriva de TLabel}
  private
    FVelocidad : integer;        {Frecuencia de parpadeo}
    FTimer : TTimer;             {Timer para la frecuencia}
    procedure SetVelocidad(valor : integer);  {Almacena la velocidad}
  protected
    procedure parpadea(Sender : TObject);
  public
    constructor Create(AOwner : TComponent); override;    {Constructor}
    destructor Destroy; override;                         {Destructor}
  published
    property Velocidad : integer read FVelocidad write SetVelocidad default 400;
  end;

procedure Register;

implementation

constructor TBlinkLabel.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);       {Llama al constructor original (heredado)}
  FTimer := TTimer.Create(Self);  {Creamos el timer}
  FVelocidad := 400;              {Frecuencia (velocidad) por defecto}
  FTimer.Enabled:=True;           {Activamos el timer}
  FTimer.OnTimer:=parpadea;       {Asiganamos el método parpadea}
  FTimer.Interval:=FVelocidad;    {Asignamos el intervalo del timer = frecuencia parpadeo}
end;

destructor TBlinkLabel.Destroy;
begin
  FTimer.Free;          {Liberamos el timer}
  inherited destroy;    {Llamamos al destructor original (heredado)}
end;

procedure TBlinkLabel.SetVelocidad (valor : integer);
begin
  If FVelocidad <> valor then        {Sólo si el valor introducido es distinto del almacenado}
  begin
    if valor < 0 then FVelocidad:=0;
    FVelocidad:=Valor;               {Asigna la velocidad}
    if FVelocidad=0 then FTimer.Enabled:=False else FTimer.Enabled:=True;
    {Si Fvelocidad=0 el mensaje debe estar siempre visible}
    FTimer.Interval:=FVelocidad;
    Visible:=True;
  end;
end;

procedure TBlinkLabel.parpadea(Sender : TObject);
begin
  if FTimer.Enabled then Visible := not(Visible);  {Alternativamente muestra y oculta el mensaje si el timer esta activado}
end;

procedure Register;        {Registro del componente}
begin
  RegisterComponents('Curso', [TBlinkLabel]);
end;

end.