Desde que aprendi Delphi em 1999, fiquei fascinado por seu rápido desenvolvimento. Naquela época, tinha acabado de entrar em contato com programação e estava particularmente interessado em desenvolvimento visual. nos últimos anos, do delphi C/S ao B/S de três camadas, também escrevi alguns softwares, grandes e pequenos. , acho que esse Delphi só tem essas funções. Como recentemente comprei um livro "Com Essence" e estudei o código-fonte da VCL, descobri que ele é realmente poderoso (não sei que palavras usar para descrevê-lo recentemente). , tem alguns avanços que são compartilhados aqui com todos. Por favor, diga-me se houver algum erro.
Para ser franco, os componentes incluem apenas dois tipos de membros: propriedades e métodos (os métodos dos quais estou falando incluem eventos)
Está dividido em quatro partes:
Privado
protegido
público
publicado
Os significados das quatro partes acima serão introduzidos em livros gerais de desenvolvimento visual. Aqui está apenas uma breve visão geral sobre Delphi.
Privado: Todos os membros privados são colocados aqui e só podem ser acessados pelos próprios métodos da classe, não pelas subclasses, e são transparentes para as subclasses. Pode-se dizer também que só pode ser acessado pelos métodos da própria unidade.
protegido: exceto que pode ser herdado por subclasses, o resto é igual a privado. Não pode ser acessado por estranhos.
público: Público, as propriedades e métodos declarados aqui podem ser chamados pelos usuários.
publicado: aparece na barra de propriedades do ambiente de desenvolvimento Delphi.
Primeiro, vamos fazer o controle mais simples. Em menos de cinco minutos, você entenderá como são feitos os componentes do painel de componentes do Delphi.
Novo->Novo->Componente e pressione Enter.
Em seguida, selecione a classe pai da qual deseja herdar em Tipo de ancestral:. Aqui escolhemos TComponent. Significa herdar todas as propriedades e métodos de TComponent.
Nome da Classe: Insira o nome da classe do componente a ser feito. (Entramos em TShowText)
Página da paleta: Em qual painel do Delphi o componente será instalado. (Escolhemos Amostras, você também pode inserir um novo nome)
Não preciso dizer o seguinte.
Clique no botão OK e o Delphi gera automaticamente um controle básico herdado do TComponent. Também pode ser entendido que desenvolvemos um controle que é tão poderoso quanto o TComponent, mas não é disso que precisamos.
A seguir são explicados os métodos de leitura e escrita das variáveis privadas do próprio componente:
Por exemplo, escrevemos o seguinte pequeno parágrafo:
privado
TextoF: String;
....
/*Variáveis privadas não podem ser usadas pelo mundo exterior, então como podemos operar esta variável de string FText? */
Também precisamos adicionar este parágrafo após a publicação:
propriedade Texto: String lida FText escreve FText;
O que isso significa aqui é que esta propriedade Text aparecerá na barra de propriedades do delphiSDK. Os usuários que modificam o Text na barra de propriedades estão na verdade modificando a variável de string FText. read significa que o usuário lê o atributo Text e realmente lê FText. Write, é claro, significa que o usuário atribui um valor a Text e o armazena na variável de string FText.
Se você salvá-lo neste momento e instalá-lo no Delphi, nosso componente mais básico estará concluído. (O método de instalação dos componentes é apresentado no final)
Haha, não é muito simples? Só que nosso componente não tem nenhum uso específico.
Acabamos de introduzir atributos aqui, agora continuaremos adicionando funções para introduzir o uso de métodos.
Adicionamos o seguinte depois de Público:
procedimento ShowText();
Em seguida, pressione Ctrl + Alt +C, o sistema adiciona automaticamente o código de implementação de alguns métodos para você.
A seguir estamos escrevendo:
procedimento TShowText.ShowText();
começar
ShowMessage(FText);
fim;
Como você pode ver, o ShowMessage acima exibe o valor da variável privada da classe. Agora você deve entender que variáveis privadas só podem ser acessadas no método da própria classe. Aqui você deve adicionar a unidade Dialogs após os usos, pois ShowMessage está incluído na unidade Dialogs, caso contrário não passará.
Claro, os eventos acima só podem ser usados no controle e não podem aparecer na barra de eventos na caixa de propriedades. Por quê? Porque o método declarado aqui é apenas Público, um método puro, e não é declarado como um evento.
Através do estudo acima, você já sabe escrever e ajustar as propriedades e métodos dos controles?
Porém, um controle real é inseparável de eventos, e a invocação de eventos deve ser conduzida por mensagens, que serão apresentadas em meu próximo artigo.
As propriedades e métodos de um controle poderoso não são tão fáceis. Requer mais prática e mais aplicações.
Anexado abaixo está um controle DBGridToExcel que escrevi, cuja função é exportar dados do DBGrid para Excel. Você pode aprender com ele e usá-lo como referência. Este controle inclui o uso de propriedades, métodos e “eventos” dos quais falaremos no próximo artigo.
Apêndice 1: Como instalar controles caseiros:
(1). No menu Componente, selecione "Instalar Componente...".
(2). Clique em "..." após o nome do arquivo de unidade, selecione o arquivo de unidade do controle "*.pas" e clique em OK. Clique em “instalar” na janela que aparece e a instalação estará concluída.
O controle recém-instalado aparece no seu painel.
Anexo 2: Copie todo o código fonte do controle TDBGridToExcel para o Bloco de Notas e salve-o como um arquivo .pas.
unidadeDBGridToExcel;
{********************************************** ***********************}
{* *}
{* Exportar grade para controle VCL do Word para D5 e D6 *}
{* Copyright(C) xiangding 2003.10.1 Todos os direitos reservados *}
{* Relatório de bug: [email protected] *}
{*Autor: Ursinho*}
{* *}
{********************************************** ***********************}
{* *}
{* Esta é uma versão simples *}
{* *}
{********************************************** ***********************}
{* *}
{* Instalar: *}
{* Salve como arquivo GridToExcel.pas e abra o arquivo *}
{* Clique no item de menu [Componente] --> [Instalar componente] *}
{* Clique no botão [Instalar] na caixa de diálogo Instalar componente *}
{* após a instalação, você pode encontrar o controle no componente *}
{* página [exemplo] *}
{* *}
{********************************************** ***********************}
{* *}
{* Instalar: *}
{* Salve o anexo e abra o arquivo GridToExcel.Pas com Delphi, *}
{* Selecione o menu Delphi-->Componente-->Instalar Componente, *}
{* Em seguida, selecione Instalar. Após a instalação, na página Amostras do painel de controle, *}
{* Depois de se familiarizar com ele, você pode tentar definir alguns atributos complexos e explorar os outros sozinho, *}
{********************************************** ***********************}
interface
usa
Windows, StdCtrls, ComCtrls, Mensagens, DBGrids, Gráficos, ExtCtrls,
Formulários, BD, ComObj, Controles, SysUtils, Classes;
String de recursos
SPromptExport = 'Aguarde, os dados estão sendo exportados...';
SConnectExcel = 'Iniciando o Excel, aguarde...';
SConnectExcelError= 'Falha ao conectar ao Excel. O Excel pode não estar instalado e não pode ser exportado.';
SCancelar = '&Cancelar';
SErro = 'erro';
SConfirm = 'Deseja realmente encerrar a exportação de dados? ';
SCaption = 'Confirmar';
SGridError = 'Nenhum conjunto de dados especificado, especifique o controle do conjunto de dados! ';
tipo
TDBGridToExcel = classe(TComponent)
privado
ProgressForm: TForm;
FShowProgress: Booleano;
ExcelApp: Variante;
FTítulo: String;
Sair: Booleano;
FOnProgress: TNotifyEvent;
FGrid: TDBGrid; {A grade de origem}
Barra de Progresso: TProgressBar;
Alerta: TLabel;
FAutoExit: Booleano;
FAutoSize: Booleano;
FDBGrid: TDBGrid;
procedimento SetShowProgress(const Valor: Boolean);
procedimento CreateProgressForm;
procedimento ButtonClick(Remetente: TObject);
Função ConnectToExcel: Booleano;
procedimento ExportDBGrid;
{Declarações privadas}
protegido
{Declarações protegidas}
público
Construtor Create(AOwner: substituição de TComponent);
Substituição do destruidor();
Procedimento ExportToExcel; {Exportar grade para Excel}
{Declarações públicas}
publicado
{Declarações publicadas}
propriedade DBGrid: TDBGrid lê FDBGrid escreve FDBGrid;
título da propriedade: String lida FTitle escrita FTitle;
propriedade ShowProgress: leitura booleana FShowProgress gravação SetShowProgress;
propriedade OnProgress: TNotifyEvent lê FOnProgress escreve FOnProgress;
fim;
Cadastro de procedimentos;
implementação
Cadastro de procedimentos;
começar
RegisterComponents('Amostras', [TDBGridToExcel]);
fim;
{TDBGridToExcel}
procedimento TDBGridToExcel.ButtonClick(Sender: TObject);
começar
Sair := MessageBox(ProgressForm.Handle, pchar(SConfirm), pchar(SCaption),
MB_OKCANCEL + MB_ICONINFORMATION) = IDOK;
fim;
função TDBGridToExcel.ConnectToExcel: Boolean;
começar
Resultado := verdadeiro;
Tentar
ExcelApp := CreateOleObject('Excel.aplicativo');
ExcelApp.Visible := Falso;
se Título<>'' então ExcelApp.Caption := Título;
ExcelApp.WorkBooks.Add;
exceto
MessageBox(GetActiveWindow,PChar(SConnectExcelError),PChar(SError),Mb_OK+MB_IconError);
resultado := falso;
fim;
fim;
construtor TDBGridToExcel.Create(AOwner: TComponent);
começar
herdado;
FShowProgress := True; {O valor padrão era Mostrar o Progresso}
FAutoExit := Falso;
FAutoSize := Verdadeiro;
fim;
procedimento TDBGridToExcel.CreateProgressForm;
var
Painel: TPanel;
Botão: Botão T;
começar
if Assigned(ProgressForm) then exit {Aready Create?}
ProgressForm := TForm.Create(Proprietário);
Com ProgressForm faça
começar
Font.Name := '宋体';
Tamanho da fonte:= 10;
BorderStyle := bsNone;
Largura:= 280;
Altura:= 120;
Largura da Borda := 1;
Cor := clFundo;
Posição := poOwnerFormCenter;
fim;
Painel := TPanel.Create(ProgressForm);
com Painel faça {Criar Painel}
começar
Pai := ProgressForm;
Alinhar := alClient;
BevelInner := bvNone;
BevelOuter := bvRaised;
Legenda := '';
fim;
Prompt := TLabel.Create(Painel);
com prompt faça {Criar etiqueta}
começar
Pai := Painel;
Esquerda:= 20;
Superior := 25;
Legenda := SConnectExcel;
fim;
ProgressBar := TProgressBar.Create(painel);
com ProgressBar faça {Criar ProgressBar}
começar
Etapa := 1;
Pai := Painel;
Suave := verdadeiro;
Esquerda:= 20;
Superior := 50;
Altura:= 18;
Largura:= 260;
fim;
Botão := TButton.Create(Painel);
com Button do {Criar botão Cancelar}
começar
Pai := Painel;
Esquerda:= 115;
Superior := 80;
Legenda := SCancelar;
OnClick := ButtonClick;
fim;
ProgressForm.Mostrar;
ProgressForm.Atualização;
fim;
destruidor TDBGridToExcel.Destroy;
começar
herdado;
fim;
procedimento TDBGridToExcel.ExportDBGrid;
var
Dados: TDataSet;
ADBGrid: TDBGrid;
eu, j: inteiro;
PontoAtual: Ponteiro;
OldBeforeScroll, OldAfterScroll: TDataSetNotifyEvent;
começar
Screen.Cursor := crHourGlass;
tentar
tentar
TForm(Proprietário).Ativado := Falso;
ExcelApp.DisplayAlerts := falso;
ExcelApp.ScreenUpdating := falso;
Sair := falso;
se ShowProgress então Prompt.Caption := SPromptExport;
ADBGrid :=DBGrid;
Dados:= ADBGrid.DataSource.DataSet;
com ADBGrid faça {Inserir cabeçalho da tabela}
para i := 1 para Columns.Count fazer
if Colunas[i - 1].Visível então
ExcelApp.Cells[1,i].Value :=Colunas[i - 1].Título.Caption;
CurrentPoint := Data.GetBookmark; {Salvar posição atual}
OldBeforeScroll := Data.BeforeScroll; {Salvar antigo antes do identificador do evento de rolagem}
OldAfterScroll := Data.AfterScroll; { Salvar identificador de evento AfterScroll antigo }
Data.DisableControls; {Desativar controle}
Data.BeforeScroll := nil;
Data.AfterScroll := nil;
se ShowProgress então ProgressBar.Max := Data.RecordCount;
eu:= 2;
Dados.Primeiro;
while not Data.Eof do {Processar todos os registros}
começar
com ADBGrid faça {Processar um registro}
para j := 1 para Columns.Count fazer
if Colunas[j - 1].Visível então
ExcelApp.Cells[i,j].Value := Colunas[j - 1].Field.DisplayText;
Inc(i);
Dados.Próximo;
se atribuído(FOnProgress) então FOnProgress(Self);
if ShowProgress then {Atualizar UI de progresso}
começar
ProgressBar.StepIt;
Application.ProcessMessages;
se sair, então saia;
fim;
fim;
exceto
MessageBox(GetActiveWindow,PChar(SConnectExcelError),Pchar(SError),MB_OK+MB_ICONERROR);
fim;
ExcelApp.Visible := Falso;
TForm(Proprietário).Ativado := Verdadeiro;
Screen.Cursor := crDefault;
if ShowProgress então FreeAndNil(ProgressForm); {Formulário de Progresso Livre}
ExcelApp.DisplayAlerts := Verdadeiro;
ExcelApp.ScreenUpdating := Verdadeiro;
finalmente
Data.BeforeScroll: = OldBeforeScroll; {Restaurar identificador de evento antigo}
Data.AfterScroll := OldAfterScroll;
Data.GotoBookmark(CurrentPoint);
Data.FreeBookmark(CurrentPoint);
Dados.EnableControls;
Screen.Cursor := crDefault;
fim;
fim;
procedimento TDBGridToExcel.ExportToExcel;
começar
se DBGrid = nil então aumente Exception.Create(SGridError); {No DataSource, then Error}
se ShowProgress então CreateProgressForm {Se mostrar ou não o ProgressForm};
se não for ConnectToExcel então {Sair quando ocorrer um erro}
começar
se ShowProgress então FreeAndNil(ProgressForm); {formulário de liberação}
saída;
fim;
ExportDBGrid; {início da exportação de dados}
fim;
procedimento TDBGridToExcel.SetShowProgress(const Valor: Boolean);
começar
FShowProgress := Valor;
fim;
fim.