O que são componentes?

A livraria visual de componentes (VCL).

Um componente, em sua definição mais simples não é mais que um objeto descendente do tipo TComponent. Todos os componentes descendem na sua forma mais primitiva de TComponent, já que TComponent proporciona as características básicas que todo componente deve ter: capacidade de ser mostrado na paleta de componentes assim como de operar a nível de desenho de formulário.

Os componentes tornam fácil a programação em Delphi. Em vez de ter que operar a nível de unidades, o usuário de um componente simplesmente tem que colocar na posição desejada no seu form. Isso é tudo: o Delphi se encarrega do resto.

Todos os componentes formam parte da Hierarquia de objetos denominada Visual Component Library (VCL). Quando se cria um novo componente, este se deriva a partir de um componente existente (bem como TComponent ou algum outro mais especializado) e se junta a VCL.

Anatomia de um componente.

Propriedades, métodos e eventos.

Como já mencionado, um componente é um objeto, e como tal, consta de código e dados. Mas ao referirmos a estes não utilizaremos estos termos, só que falaremos de propriedades e métodos, assim como de eventos. A longo do curso iremos estudando em profundidade todos estes aspectos, mas teremos agora uma primeira aproximação:

• Propriedades

As propriedades proporcionam ao usuário do componente um fácil acesso ao mesmo. Ao mesmo tempo, permite ao programador do componente "esconder" a estrutura de dados subjacente. Entre as vantagens de utilizar propriedades para usar o componente se podem citar:

• As propriedades estão disponíveis em tempo de desenho. Deste modo o usuário do componente pode iniciar os valores das propriedades sem necessidade de escrever uma só linha de código.

• As propriedades permitem a validação dos dados ao mesmo tempo de ser introduzidas. Assim se podem prevenir erros causados por valores inválidos.

• Nos asseguram que desde o primeiro momento nossas propriedades tenham um valor válido, evitando o erro comum de fazer referência a uma variável que não tenha sido convenientemente iniciada.

• Eventos

Os eventos são as conexões existentes entre um determinado evento e ao código escrito pelo programador de componentes. Assim por exemplo, quando ao evento clique do Mouse se poderia mostrar uma mensagem. Ao código que se executa quando se produz um determinado evento se denomina controlador de eventos (event handler) e normalmente é o próprio usuário do componente quem o escreve. Os eventos mais comuns já formam parte dos próprios componentes do Delphi (ações do Mouse, pressionamento do teclado...), mas é também possível definir novos eventos.

• Métodos

Os métodos são os procedimentos e/ou funções que formam parte do componente. O usuário do componente os utiliza para realizar uma determinada ação ou para obter um valor determinado que não se pode acessar por meio de uma propriedade. Já que requerem execução de código, os métodos só estão disponíveis em tempo de execução.

Controle de acesso a um componente.

Declarações privadas, protegidas, públicas e publicadas.

Object Pacal dispõe de quatro níveis de controle de acesso para os campos, propriedades e métodos de um componente. Este controle de acesso permite especificar ao programador do componentes que parte do código pode acessar a que partes do objeto. Deste modo se define a interface do componente. É importante planejar bem esta interface, já que assim nossos componentes serão facilmente programáveis e reutilizáveis.

Ao menos que se especifique o contrário, os campos, propriedades e métodos que se unem a um objeto são do tipo publicados (published). Todos os níveis de controle de acesso operam a nível de unidades, é decidir se uma parte dum objeto é acessível ou não, em uma parte da unidade, é também acessível (ou não) em qualquer outra parte da unidade.

Privado: ocultando os detalhes de implementação

Declarando uma parte de um componente (bem como um campo, propriedade ou método) privado (private) provoca que essa parte do objeto seja invisível ao código externo a unidade na qual se declara o objeto. Dentro da unidade que contem a declaração, o código pode acessar a essa parte do objeto como se fosse público.

A principal utilidade das declarações privadas é que permitem ocultar os detalhes de implementação do componente ao usuário final do mesmo, já que estes não podem acessar a parte privada de um objeto. Deste modo se pode trocar a implementação interna do objeto sem afetar o código que havia escrito ao usuário.

Protegido: definindo a interface do programador.

Declarar uma parte de um componente como protegido (protected) provoca, o mesmo se declarado privado, que ao código externo a unidade não pode acessar a dita parte (se faz oculta ao código externo a a unidade). A diferença principal entre declarar uma parte de um objeto protegido ou privado é que os descendentes do componente podem fazer referência a essa parte.

Este comportamento é especialmente útil para a criação de componentes que vão se descender daquilo que criamos.

Público: definindo a interface em tempo de execução.

Todas partes de um objeto que declaremos públicas (public) poderiam ser referidas por qualquer código seja interno ou externo a própria unidade. Neste sentido, a parte pública identifica a interface em tempo de execução de nosso componente. Os métodos que o usuário do componente deve chamar devem ser declarados públicos, assim como também as propriedades de somente leitura, são somente válidas em tempo de execução.

As propriedades declaradas públicas não aparecerão no inspetor de objetos.

Esta seção é talvez a mais importante a considerar ao desenhar um componente. Quando se desenham componentes, se deve considerar cuidadosamente que métodos e propriedades devem ser públicas. Se o desenho é correto, este permitira retocar as estruturas de dados e métodos internos do componente sem ter que tocar a interface pública, que seguirá sendo a mesma para o usuário do componente.

Publicado: definindo a interface em tempo de desenho.

Ao declarar parte de um objeto publicado (published) ocorre que a parte pública e ademais gera informações em tempo de execução para dita parte. As propriedades declaradas publicadas aparecem no inspetor de objetos em tempo de desenho. E já que somente as partes publicadas aparecem no inspetor de objetos, estas partes definem a interface em tempo de desenho do nosso componente. Em geral somente se devem declarar publicadas propriedades e não funções ou procedimentos.

Passos necessários para criar um componente.

O criador de componentes.

Os passos necessários para criar um novo componente são os seguintes:

1. Criar uma unidade para o novo componente.

2. Derivar o novo componente a partir de outro existente, o qual servirá de base para as novas características desejadas.

3. Estabelecer as propriedades, eventos e métodos necessários ao novo componente.

4. Registrar o componente, incluindo os bitmaps adicionais, arquivos de ajuda, etc.

5. Instalar o novo componente na paleta de componentes.

De todos os passos citados, há um que é especialmente importante: a eleição do ascendente a partir da qual derivar o novo componente. Este passo é crucial, já que uma boa eleição do ascendente pode fazer a tarefa de criar novas propriedades e métodos realmente fácil. Como base para a eleição do ascendente, convém fazer notar as seguintes normas:

• TComponent - O ponto de partida para os componentes não visuais.

• TWinControl - O ponto de partida se é necessário que o componente disponha de handles.

• TGraphicControl - Um bom ponto de partida para componentes visuais que não seja necessário que disponham de handles, posso dizer, que não recebam o foco. Esta classe dispõe do método Paint e de Canvas.

• TCustomControl - O ponto de partida mais comum. Esta classe dispõe de window handle, eventos e propriedades comuns e, principalmente, canvas com o método Paint.

Bom, já sabemos como determinar o ponto de partida. Vejamos agora como criar a unidade que abrigará o componente. Há duas opções, criar a unidade manualmente ou deixar que o Delphi faça o trabalho "sozinho" utilizando o experto de componentes. Se optarmos pela primeira solução, basta dar um click em New Unit e poremos mãos a obra, mas deste modo teremos que fazer tudo manualmente: derivar o novo componente, registrá-lo, etc. Por isso é mais recomendável a segunda opção: utilizar o experto de componentes.

Para abrir o experto de componentes basta escolher File|New Component.

Aparecerá um quadro de diálogo que devemos complementar os seguintes campos:

• Class Name: Aqui devemos especificar o nome do novo componente.

• Ancestor type: Introduziremos aqui o ascendente a partir do qual derivaremos nosso componente.

• Palette Page: Indicaremos aqui a página da paleta na qual queremos que apareça o novo componente.

Uma vez introduzidos estes campos, clique em Ok para que seja criado o código de nossa unidade. Se por exemplo termos introduzido os seguintes dados no experto de componentes:

Class Name: TMiComponente

Ancestor Type: TComponent

Palette Page: Curso

Ao clicar em Aceitar, Delphi geraria a seguinte unidade, pronta para introduzir as propriedades e métodos de nosso 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 daqui tudo consiste em introduzir as propriedades e métodos necessários para o funcionamento do nosso componente. Mas antes de nada convém fazer notar alguns aspectos:

Na clausula uses, Delphi originalmente as unidades standard. Se nosso componente não usa alguma delas podemos eliminá-la de dita clausula. Do mesmo modo, se utilizarmos algum procedimento ou função situado em outra unidade, devemos citar a dita unidade na clausula uses.

As declarações das propriedades, campos e métodos que vamos definindo, as citaremos na seção apropriada que corresponda, é decidir se as declararemos privadas, protegidas, pública o publicadas.

Delphi declara e define automaticamente o procedimento Register para registrar o componente na paleta.