![]() |
|
![]() |
Voltar ao índice | Por
Luis Roche ![]() |
Os componentes são a pedra angular da programação em Delphi. Embora a maioria dos componentes representam partes visíveis da interface de usuário, também existem os componentes não-visuais, como por o exemplo o objeto Cronômetro e Banco de dados.
Um componente, em sua definição mais simples mais é um objeto descendente tipo TComponent. Todos os componentes descendem na forma mais primitiva do TComponent, desde que TComponent provê as características básicas que todo o componente deveria ter: capacidade de ser mostrado na paleta de componentes como também de operar em "Design-time" .
Os componentes fazem a programação em Delphi ficar mais facil. Em vez de ter que operar a nível de unidades, o usuário de um componente tem que preencher as propriedades dele e localizar isto na posição querida da forma dele simplesmente. Isso é tudo:O Delphi se encarrega do resto.
Todos os componentes são parte da hierarquia de Biblioteca de
Componente de objetos denominada Visual (VCL). Quando um componente novo
é criado, este é derivado a partir de um componente existente
(bem como o TComponent ou algum outro especializado) e é somado
ao VCL.
Anatomia de um componente. Propriedades, métodos
e eventos.
Os eventos são as conexões existentes entre um certo evento e o código escrito pelo programador de componentes. Deste modo por exemplo, antes do clique de evento do mouse poderia se mostrar uma mensagem em tela. Para o código que é executado quando um certo evento o leva a um lugar é denominado Gerenciador de Eventos (o Gerenciador de Eventos) é normalmente escrito pelo usuario do componente. Os eventos mais comuns já são parte dos próprios componentes de Delphi (eventos do mouse, teclado...), mas também é possível definir eventos novos.
Os métodos são as funções de E/S de procedimentos que eles são parte do componente. O usuário do componente os usa para obter uma certa ação ou obter um certo valor para o qual você não pode conseguir por meio de uma propriedade. Considerando que eles requerem execução de código, os métodos estão disponíveis só em run-time.
O Object Pascal tem quatro níveis de controle de acesso para os campos, propriedades e métodos de um componente. Este controle de acesso permite o programador de componentes em que partes do código especificar as declarações do objeto. Deste modo é definido a interface do componente. É importante planejar bem esta interface, deste modo nossos componentes serão facilmente programáveis e reutilizaveis.
A menos que o oposto seja especificado, os campos, propriedades e métodos
que são somados a um objeto são de tipo published. Todos
os níveis de controle de acesso operam a nível de unidades,
quer dizer, se uma parte de um objeto é acessível (ou inacessível)
em uma parte de uma unidade, é também acessível (ou
inacessível) em qualquer outra parte da unidade.
Logo os tipos de controles de acesso são detalhados:
Declarando uma parte de um componente (bem é um campo, propriedade ou método) private (você se priva). Aquela parte do objeto é invisível ao código externo para a unidade no o qual o objeto é declarado. Dentro da unidade que contém a declaração, o código como o que pode consentir àquela parte do objeto se fosse público.
A utilidade principal das declarações privadas é que eles permitem esconder os detalhes de implementação do componente para o usuário final do mesmo, desde estes eles não podem consentir à parte privada de um objeto. Deste modo você pode mudar o implementação interno do objeto sem afetar ao código que o usuário escreveu.
Declarar uma parte de um componente como sendo protegido é o mesmo que declarar isto em privado. (é escondido ao código externo à unidade). A diferença principal entre declarar uma parte de um objeto protegido ou fazer isto privado são que os descendentes do componente poderão fazer referência àquela parte.
Este parte é especialmente útil para o criação
de componentes.
As partes inteiras de um objeto que nós declaramos público, eles poderão ser indexado por qualquer código interno ou externo para a própria unidade. Deste modo, a parte pública identifica a interface a tempo de execução de nosso componente. Os métodos que o usuário do componente deveria chamar os públicos deveria ser declarado, como também as propriedades de read-only, para ser só válido a tempo de execução.
O público declara as propriedades que não aparecerão no Object Inspector.
Esta seção é talvez mais importante considerar quando estamos projetando um componente. Quando são projetados componentes, deveriam ser considerados cuidadosamente que métodos e propriedades deveriam ser públicas. Se o código está correto, isto permitirá a alteração as estruturas de dados e métodos internos do componente sem ter que jogar o público da interface que continuará sendo o mesmo para o usuário do componente.
Published: definindo a interface a design-time:
Quando declarando parte de um objeto publicado é o mesmo que a pública e também gera a informação em run-time.
As propriedades declaradas publicadas aparecem no Object Inspector. Estas partes definem a interface a design-time de nosso componente.
As grandes características, os passos necessários para criar um componente novo são o seguinte:
Abrir o expert de componentes no menu Component e New Component...
Aparecerá uma caixa de diálogo na qual nós
devemos preencher os campos:
Quando clicamos aceitando,O Delphi nos geraria a unidade seguinte, listada abaixo 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 o que consiste em introduzir as propriedades e métodos necessários para a operação de nosso componente. Mas antes de qualquer coisa deve se fazer algumas advrtências em alguns aspectos:
Na cláusula uses, o Delphi soma por padrão as unidades standards. Se nosso componente não usa alguns deles que nós podemos eliminar isto desta cláusula. Da mesma maneira, se nós usamos algum procedimento ou função localizada em outra unidade, nós deveríamos adicionar esta unidade para a cláusula que uses.
As declarações das propriedades, campos e métodos que nós vamos definir, os localizará na seção apropriada da interface como corresponde, quer dizer nós os declararemos private, protected, public ou published.
O Delphi declara e define o registro de procedimento automaticamente
para registrar o componente na paleta.