Mini-curso - Criando componentes

Bem amigos, h� muito tempo que venho querendo ministrar um curso para ensinar a desenvolver componentes em Delphi. � uma forma de aprender mais e passar o conhecimento que obtive com meus colegas do f�rum e com alguns livros que li. Ent�o m�os � obra, pois temos muito trabalho a fazer.

Conhecendo a estrutura

No in�cio o desenvolvimento de componentes, confesso, � um pouco confuso, mas logo voc� ir� se apaixonar por seus pr�prios componentes, prometo.

A primeira coisa que se deve ter em mente � que componentes s�o desenvolvidos sem aux�lio pleno no que diz respeito a visual, ou seja, � basicamente a digitaç�o de classes, procedures e functions. Por isso � necess�rio se ter uma boa noç�o de como criar procedimentos, funç�es, classes e etc.

Voc� deve estar se perguntando: Na Internet existem milhares de componentes gratuitos e at� com c�digo fonte aberto, porque desenvolv�-los? Para responder esta quest�o faço uso de duas palavras que resumem tudo: controle e personalizaç�o. Nem sempre encontramos componentes que se encaixem com nossa realidade, da� surge a necessidade de cri�-los.

Para este nosso primeiro artigo, vamos criar um componente bem interessante e �til. O TexTabToEnter. O componente far� o trabalho de trocar o tab pelo enter em toda a aplicaç�o. Calma, calma. A ideia inicial � que possamos ver o b�sico da criaç�o de um componente, pois o TexTabToEnter existe aos montes na grande teia, vamos apenas treinar.

Nota: Usarei o prefixo �ex� para todos os componentes que criaremos em nossos exemplos.

Por onde começar?

O in�cio de um projeto de componente � bem mais simples do que muitos imaginam.

Abra o Delphi e logo em seguida feche o projeto default que se abre usando a opç�o Close All no menu File. Depois disso basta acionar a opç�o New Component presente no meu Component. Uma caixa de di�logo aparecer� (veja Figura 1) e nela vamos preencher alguns par�metros.

Figura 1. Di�logo de criaç�o do componente

Nesta caixa de di�logo definimos informaç�es referentes ao nosso novo componente conforme explicaç�o:

Ancestor type: Classe "pai" do nosso componente, ou seja, de qual classe nosso componente ser� "parente". No caso TComponent.
Class Name: Nome da nova classe que estamos criando. Vamos usar em nossos exemplos o prefixo "ex" de exemplo para todas as classes.
Pallete Page: Em qual paleta do Delphi nosso componente ser� instalado.
Unit file name: Informe ao Delphi em qual diret�rio ser� salvo nosso componente.

Ap�s a configuraç�o dessas informaç�es basta clicar em Ok para que o Delphi crie pra n�s o escopo inicial de nosso componente e olhando com atenç�o para nossa nova Unit vemos que existem algumas seç�es que n�o encontramos em nossos programas (veja a Listagem 1).


unit exTabToEnter;
 
interface;
 
uses 
  SysUtils, Classes;
 
type 
  TexTabToEnter = class(TComponent);
  private 
    {Private Declarations}
  protected 
    {Protected Declarations}
  public 
    {Public Declarations}
  published 
    {Published Declarations}
  end; 
 
procedure Register;
 
implementation 
 
procedure Register;
begin
  RegisterComponents('ClubeDelphi', [TabToEnter]);
end;
 
end.

Listagem 1. Unit do nosso componente ainda sem nenhuma implementaç�o

Implementando funcionalidades

Para este primeiro projetos, vamos fazer algo bem simples.

Nosso componente ser� respons�vel por fazer com que o Enter funcione como TAB em nossos sistemas.

A m�gica consiste em �desviar� o evento onMessage do objeto TApplication para uma funç�o Execute do componente que por sua vez far� a �troca� de Tab para Enter.

Nota: Na verdade n�o faremos a troca, afinal de contas o tab continuar� tendo sua funcionalidade.

Vamos precisar de apenas uma propriedade: Ativo do tipo Boolean. Esta propriedade quando ativa ser� checada pela procedure Execute realizando a tarefa desejada. Para criar uma propriedade basta usar a palavra reservada property na seç�o Published. Esta seç�o � respons�vel por publicar nossas propriedades no Object Inspector, ou seja, ser� vis�vel para o desenvolvedor em tempo de projeto. (veja a Listagem 2).

unit exTabToEnter;
 
interface;
 
uses 
  Windows, Messages, SysUtils, Classes;
 
type 
  TabToEnter = class(TComponent);
 
  private 
    {Private Declarations}
    FAtivo : Boolean;
  protected 
    {Protected Declarations}
  public 
    {Public Declarations}
  published 
    {Published Declarations}
    property Ativo: Boolean read FAtivo write FAtivo;
  end; 
 
procedure Register;
 
implementation 
 
procedure Register;
begin
  RegisterComponents('ClubeDelphi', [TabToEnter]);
end;
 
end.

Listagem 2. Declaraç�o da propriedade Ativo

Como podemos notar, fizemos a declaraç�o da propriedade em Published e a criaç�o de uma vari�vel (FAtivo) em private. O efe �F� na frente da vari�vel � uma convenç�o e significa Field.

Nota: Quando criamos a propriedade informamos a ela que a leitura (read) e sua escrita (write) ser� feita atrav�s do campo FAtivo.

Para finalizar nosso componente precisamos implementar os m�todos: Constructor (construtor), Destructor (destrutor) e Execute (executar, este m�todo far� a principal tarefa do componente).

Para isso faça as declaraç�es dos m�todos como na Listagem 3 e logo em seguida pressione Ctrl + Shift + C, isso far� com que o Delphi crie automaticamente o corpo dos m�todos.

Para este artigo n�o h� necessidade de fazer mudanças ou inserç�o de algor�timos em nosso construtor e destrutor. J� no m�todo Execute voc� ter� que programar a tarefa que este componente ter� que realizar. A listagem completa est� presente em Listagem 3.


unit exTabToEnter;
 
interface;
 
uses 
  Windows, Messages, SysUtils, Classes;
 
type 
  TabToEnter = class(TComponent);
 
  private 
    {Private Declarations}
    FAtivo : Boolean;
  protected 
    {Protected Declarations}
  public 
    {Public Declarations}
    constructor Create(AOWner: TComponent); override;
    destructor Destroy;override;
    procedure Execute(var Msg: TMsg; var Handled: Boolean);
  published 
    {Published Declarations}
    property Ativo : Boolean read FAtivo write FAtivo;
  end; 
 
procedure Register;
 
implementation 
 
procedure Register;
begin
  RegisterComponents('ClubeDelphi', [TabToEnter]);
end;
 
procedure TexTabToEnter.Destroy;
begin
  inherited;
end;
 
procedure TexTabToEnter.Constructor(AOWner: TComponent);
begin
  inherited;
end;
 
procedure TexTabToEnter.Execute;
begin
   if (FAtivo) or not (csDesigning in ComponentState) then
   begin
     if not ((Screen.ActiveControl is TCustomMemo) or
       (Screen.ActiveControl is TCustomGrid) or
       (Screen.ActiveControl is TButton) or
       (Screen.ActiveControl is TBitBtn) or
       (Screen.ActiveForm.ClassName = 'TMessageForm')) then
       if (Msg.message = WM_KEYDOWN) then
         Case Msg.wParam of
           VK_RETURN,VK_DOWN: Screen.ActiveForm.Perform(WM_NextDlgCtl, 0, 0);
           VK_UP: Screen.ActiveForm.Perform(WM_NextDlgCtl,1,0);
         end;
   end
   else
     Application.OnMessage := nil;
end;
end.

Listagem 3. Listagem completa do componente

Nota: No trecho de c�digo �not (csDesigning in ComponentState)� verificamos se o componente est� sendo usando em tempo de design, ou seja, ainda na IDE do Delphi e ent�o passamos o valor nil para ele. Do contr�rio os di�logos do Delphi iriam adquirir a funcionalidade do componente, trocando o Tab pelo Enter.

Declaraç�o

Como dito anteriormente, existem quatro seç�es na unit do componente, diferente do que estamos acostumados a ver no dia-a-dia. S�o elas: private, public, protected e published.

As propriedades podem ser declaradas em qualquer seç�o, por�m apenas na seç�o published � que estar�o vis�veis no Object Inspector. Cada propriedade necessita de uma funç�o ou campo para leitura e escrita. Os campos s�o na verdade vari�veis precedidas do prefixo "F", uma convenç�o da Borland que significa Field (campo) e n�o podem ser declaradas na seç�o published. Tamb�m � comum criarmos funç�es e procedimentos para a leitura e escrita da propriedade quando necess�rio. O mais comum � que todas as vari�veis sejam declaradas na seç�o private, pois apenas o componente ter� acesso a elas.

Caso a propriedade necessite de um tratamento especial ent�o criamos uma funç�o para leitura e um procedimento para escrita, veremos mais a seguir um exemplo pr�tico.

Declaraç�o na pr�tica

Faremos a criaç�o de um componente capaz de capturar os erros em nossos aplicativos e o mostraremos de uma mensagem mais amig�vel para o usu�rio final. Para isso criaremos as seguintes propriedades apresentadas na Tabela 1.

Propriedade	Tipo	Finalidade
Ativo	Boolean	Ativa e Desativa o componente
Mensagem	String	Mensagem ao usu�rio
Dialogo	TTipoDialogo	Tipo de mensagem que ser� exibida

Tabela 1. Propriedades do novo componente.

Pr�tica

Abra o Delphi e crie a unit do novo componente. Daremos o nome de TexCapturaErro e o criaremos paleta ClubeDelphi. Declare as propriedades como na Listagem 4.

unit exCapturaErro;
  
 interface 
  
 uses 
   SysUtils, Classes, Dialogs, Forms;
  
 type 
   TTipoDialogo = (tdAviso, tdErro, tdInformacao);
  
 type
   TexCapturaErro = class(TComponent)
   private
     { Private Declarations }
     FAtivo : Boolean;
     FMensagem : string;
     FTipoDialogo : TTpoDialogo;
   proctected 
     { Protected Declarations }
     constructor Create(AOWner: TComponent);override;
   public 
     { Public Declarations }
   published
     { Published Declarations }
     property Ativo : Boolean read FAtivo write FAtivo;
     property Mensagem : String read FMensagem write FMensagem;
     property TipoDialogo : TTipoDialogo read GetDialogo write SetDialogo;
   end;
  
 procedure Register;
  
 implementation
  
 procedure Register;
 begin
   RegisterComponents('ClubeDelphi', [TexCapturaErro]);
 end;
  
 procedure Create(AOWner: TComponent);
 begin
   inherited;
   Application.OnException := Execute;
 end;
 end.

Listagem 4. Declaraç�o de vari�veis e propriedades

Algumas explicaç�es

Logo abaixo do uses de nosso componente criamos um novo tipo, o TTipoDialogo. Isso � que o chamamos de vari�veis tipadas. Nosso usu�rio poder� escolher se o componente ir� mostrar uma mensagem de Aviso, Erro ou apenas uma Informaç�o.

Para o uso disso, basta declarar uma vari�vel/campo do mesmo tipo declarado acima. E tamb�m declarar nossa property do mesmo tipo usando para leitura e escrita a vari�vel declarada.

Ap�s declaradas as propriedades, basta pressionar Ctrl + Shift + C para que o Delphi crie automaticamente o escopo das funç�es/procedimentos necess�rios.

Repare que criamos um construtor para o novo componente, nos pr�ximos artigos veremos mais detalhadamente como funcionam. O c�digo para a leitura e escrita da propriedade TipoDialogo � bem simples. (veja Listagem 5.)

...
 funtion TexCapturaerro.GetTipoDialogo: FTipoDialogo;
 begin
   Result := FTipoDialogo;
 end;
  
 procedure TexCapturaerro.SetTipoDialogo(Value: FTipoDialogo);
 begin
   FTipoDialogo := Value;
 end;
 ...
 end.

Listagem 5. Leitura e Escrita da propriedade TipoDialogo

Funç�o Execute

Agora precisamos desenvolver o algoritmo que capturar� mostrar a mensagem ao usu�rio. Declare a funç�o Execute como na Listagem 6 e seu algoritmo como na Listagem 7.

...
   public 
     { Public Declarations }
     procedure Execute(Sender: Tobject; E: Exception); 
   published
 ...

Listagem 6. Leitura e Escrita da propriedade TipoDialogo

...
 procedure TexCapturaerro.Execute(Sender: Tobject; E: Exception); 
  
 var
   Dialogo : TMsgDlgType; 
  
 begin
   if FAtivo then 
   begin
     case FTipoDialogo of
       tdAviso : mtWarning;
       tdErro : mtError;
       tdInformacao : mtInformation;
     end;
     Beep;
     MessageDlg(FMensagem + #13#13#13 + E.Message, Dialogo, [mbOk], 0);
   end
   else
     Application.ShowException(E);
 end;
 ...

Listagem 7. Leitura e Escrita da propriedade TipoDialogo

�timo, agora basta instalar o componente e testar.

Conclus�es

Neste artigo entendemos melhor como funciona a declaraç�o de vari�veis inclu�do vari�veis tipadas.