Creación de componentes VCL: Componentes gráficos - No esta bien copiar, pero sí coger ideas

Todo esto lo vamos a hacer a través de dos clases: una para los colores de las casillas, llamada TColoresCasillas, y otra para la configuración del borde, llamada TBordeTablero, tal y como podéis ver en el siguiente listado:

  TColoresCasillas = class(TPersistent)
   private
      FTablero: TTablero;
 
      FCasillasBlancas: TColor;
      FCasillasNegras: TColor;
 
      procedure SetCasillasBlancas(value: TColor);
      procedure SetCasillasNegras(value: TColor);
 
   public
      constructor Create(tablero: TTablero);
 
   published
      property CasillasBlancas: TColor 
               read    FCasillasBlancas 
               write   SetCasillasBlancas 
               default clWhite;
 
      property CasillasNegras: TColor 
               read    FCasillasNegras 
               write   SetCasillasNegras 
               default clBlack;
   end;
 
 
   TBordeTablero = class(TPersistent)
   private
      FTablero: TTablero;
 
      FMostrar: boolean;
      FColor: TColor;
 
      procedure SetMostrar(value: boolean);
      procedure SetColor(value: TColor);
   public
      constructor Create(tablero: TTablero);
   published
      property Mostrar: boolean 
               read    FMostrar 
               write   SetMostrar 
               default true;
 
     property Color:  TColor 
              read    FColor 
              write   SetColor 
              default clBlack;
   end;
 
 

Ya en el componente TTablero, simplemente debemos definir dos propiedades, una para cada clase que acabamos de crear, y automáticamente, el Inspector de Objetos mostrará las propiedades agrupadas, tal y como podéis ver en la imagen de la derecha.

Uno de los detalles más importantes es la codificación de los métodos de escritura de las propiedades. Cuando somos los responsables del dibujado del componente, el cambio del valor de algunas propiedades provocan que el aspecto del componente cambie. Para ello, debemos lanzar la operación de pintado cuando el valor de la propiedad cambie, por ejemplo: cuando se cambie el color que debemos utilizar para pintar las casillas. Para lanzar esta operación, debemos hacer uso del método Invalidate, que viene heredado de TControl. Con este método, provocado un repintado completo del componente, llamándose al método Paint, y lanzándose así todo el código que hemos escrito para dibujar en la pantalla. Podéis ver cómo se llama a este método en el siguiente listado:

  procedure TColoresCasillas.SetCasillasBlancas(value: TColor);
   begin
      if value <> FCasillasBlancas then
      begin
         FCasillasBlancas := value;
         FTablero.Invalidate;
      end;
   end;
 
 

Es conveniente utilizar este método con cautela, ya que cada vez que se llame provocaremos un repintado del componente, aunque varias llamadas consecutivas desembocarán en un único repintado. En el último listado, podéis ver un ejemplo en que evitamos el uso de Invalidate, en un caso en que es suficiente pintar el borde, y no el componente completo.

  procedure TBordeTablero.SetMostrar(value: boolean);
   begin
      if value <> FMostrar then
      begin
         FMostrar := value;
 
         if FMostrar then
            FTablero.DibujarBorde(FColor) // sólo se dibuja el borde
         else
            FTablero.Invalidate; // se dibuja todo
      end;
   end;