Desde que aprendí Delphi en 1999, me ha fascinado su rápido desarrollo. En ese momento, acababa de entrar en contacto con la programación y estaba particularmente interesado en el desarrollo visual. La razón es que se puede implementar más rápido que C. En los últimos años, desde Delphi C/S hasta B/S de tres capas, también he escrito algún software, grande y pequeño. Creo que este Delphi solo tiene estas funciones. Recientemente, compré un libro "Com Essence Theory" y estudié el código fuente de VCL, solo para descubrir que es realmente poderoso (no sé qué palabras usar para describirlo). Recientemente, algunos avances se comparten aquí con todos. Por favor, díganme si hay algún error.
Para decirlo sin rodeos, los componentes sólo incluyen dos tipos de miembros: propiedades y métodos (los métodos de los que hablo incluyen eventos)
Está dividido en cuatro partes:
Privado
protegido
público
publicado
El significado de las cuatro partes anteriores se presentará en libros de desarrollo visual general. Aquí se ofrece solo una breve descripción general de Delphi.
Privado: todos los miembros privados se colocan aquí y solo se puede acceder a ellos mediante los métodos propios de la clase, no mediante las subclases, y son transparentes para las subclases. También se puede decir que solo se puede acceder a él mediante los métodos de la propia unidad.
protegido: excepto que puede ser heredado por subclases, el resto es igual que privado. No puede ser accedido por personas ajenas.
público: Público, los usuarios pueden llamar a las propiedades y métodos declarados aquí.
publicado: aparece en la barra de propiedades del entorno de desarrollo Delphi.
Primero, hagamos el control más simple. En menos de cinco minutos, comprenderá cómo se fabrican los componentes del panel de componentes de Delphi.
Nuevo->Nuevo->Componente y presione Enter.
Luego seleccione la clase principal de la que desea heredar en Tipo de antepasado:. Aquí elegimos TComponent. Significa heredar todas las propiedades y métodos de TComponent.
Nombre de clase: Ingrese el nombre de clase del componente que se creará. (Ingresamos a TShowText)
Página de paleta: en qué panel de Delphi se instalará el componente. (Elegimos Muestras, también puedes ingresar un nuevo nombre)
No necesito decir lo siguiente.
Haga clic en el botón Aceptar y Delphi generará automáticamente un control básico heredado de TComponent. También se puede entender que hemos desarrollado un control que es tan poderoso como TComponent, pero esto no es lo que necesitamos.
A continuación se explican los métodos de lectura y escritura de las variables privadas del propio componente:
Por ejemplo, escribimos el siguiente breve párrafo:
privado
FText: Cadena;
....
/* El mundo exterior no permite el uso de variables privadas, entonces, ¿cómo podemos operar esta variable de cadena FText? */
También necesitamos agregar este párrafo después de Publicado:
texto de propiedad: cadena leída FText escritura FText;
Lo que esto significa aquí es que esta propiedad de Texto aparecerá en la barra de propiedades de delphiSDK. Los usuarios que modifican el Texto en la barra de propiedades en realidad están modificando la variable de cadena FText. leer significa que el usuario lee la propiedad Texto y realmente lee FText. Escribir, por supuesto, significa que el usuario asigna un valor a Texto y lo almacena en la variable de cadena FText.
Si lo guarda en este momento y lo instala en Delphi, nuestro componente más básico estará terminado. (El método de instalación de componentes se presenta al final)
Jaja, ¿no es muy sencillo? Es solo que nuestro componente no tiene ningún uso específico.
Acabamos de introducir atributos aquí, ahora continuaremos agregando funciones para introducir el uso de métodos.
Agregamos lo siguiente después de Público:
procedimiento MostrarTexto();
Luego presione Ctrl + Alt + C, el sistema agrega automáticamente el código de implementación de algunos métodos.
A continuación escribimos:
procedimiento TShowText.ShowText();
comenzar
Mostrar mensaje (FText);
fin;
Como puede ver, el ShowMessage anterior muestra el valor de la variable privada de la clase. A estas alturas ya debería comprender que solo se puede acceder a las variables privadas en el método de la clase misma. Aquí debe agregar la unidad de Diálogos después de su uso, porque ShowMessage está incluido en la unidad de Diálogos, de lo contrario no pasará.
Por supuesto, los eventos anteriores solo se pueden usar en el control y no pueden aparecer en la barra de eventos en el cuadro de propiedades. Porque el método declarado aquí es solo público, un método puro y no se declara como un evento.
A través del estudio anterior, ¿sabe ya cómo escribir y ajustar las propiedades y métodos de los controles?
Sin embargo, un control real es inseparable de los eventos, y la invocación de eventos debe ser impulsada por mensajes, que se presentarán en mi próximo artículo.
Las propiedades y métodos de un control potente no son tan fáciles. Requiere más práctica y más aplicaciones.
Se adjunta a continuación un control DBGridToExcel que escribí, cuya función es exportar datos en DBGrid a Excel. Puedes aprender de él y utilizarlo como referencia. Este control incluye el uso de propiedades, métodos y "eventos" de los que hablaremos en el próximo artículo.
Apéndice 1: Cómo instalar controles de fabricación propia:
(1). En el menú Componente, seleccione "Instalar componente...".
(2). Haga clic en "..." después del nombre del archivo de unidad, seleccione el archivo de unidad del control "*.pas" y luego haga clic en Aceptar. Haga clic en "instalar" en la ventana que aparece y la instalación se completará.
El control recién instalado aparece en su panel.
Adjunto 2: Copie el código fuente completo del control TDBGridToExcel al Bloc de notas y guárdelo como un archivo .pas.
unidad DBGridToExcel;
{*************************************************** ***** *************************}
{* *}
{* Exportar cuadrícula a control Word VCL para D5 y D6 *}
{* Copyright(C) xiangding 2003.10.1 Todos los derechos reservados *}
{* Informe de error: boyxd@163.net *}
{*Autor: Osito*}
{* *}
{*************************************************** ***** *************************}
{* *}
{* Esta es una versión simple *}
{* *}
{*************************************************** ***** *************************}
{* *}
{* Instalar: *}
{* Guarde como archivo GridToExcel.pas y luego abra el archivo *}
{* Haga clic en el elemento del menú [Componente] --> [Instalar componente] *}
{* Haga clic en el botón [Instalar] en el cuadro de diálogo Instalar componente *}
{* después de la instalación, puede encontrar el control en el componente *}
{* página [muestra] *}
{* *}
{*************************************************** ***** *************************}
{* *}
{* Instalar: *}
{* Guarde el archivo adjunto y luego abra el archivo GridToExcel.Pas con Delphi, *}
{* Seleccione el menú Delphi-->Componente-->Instalar componente, *}
{* Luego seleccione Instalar. Después de la instalación, en la página Ejemplos del panel de control, *}
{* Una vez que esté familiarizado con él, puede intentar establecer algunos atributos complejos y explorar los demás usted mismo, *}
{*************************************************** ***** *************************}
interfaz
usos
Windows, StdCtrls, ComCtrls, Mensajes, DBGrids, Gráficos, ExtCtrls,
Formularios, DB, ComObj, Controles, SysUtils, Clases;
Cadena de recursos
SPromptExport = 'Espere, los datos se están exportando...';
SConnectExcel = 'Iniciando Excel, espere...';
SConnectExcelError= 'Error al conectarse a Excel. Es posible que Excel no esté instalado y no se pueda exportar.';
SCancelar = '&Cancelar';
SError = 'error';
SConfirm = '¿Realmente desea finalizar la exportación de datos? ';
SCaption = 'Confirmar';
SGridError = 'No se ha especificado ningún conjunto de datos, especifique el control del conjunto de datos. ';
tipo
TDBGridToExcel = clase(TComponent)
privado
Formulario de progreso: TForm;
FShowProgress: booleano;
ExcelApp: Variante;
FTítulo: Cadena;
Salir: booleano;
FOnProgress: TNotifyEvent;
FGrid: TDBGrid; {La cuadrícula de origen}
Barra de progreso: TProgressBar;
Mensaje: TLabel;
FAutoSalida: booleano;
FAutoSize: booleano;
FDBGrid: TDBGrid;
procedimiento SetShowProgress (valor constante: booleano);
procedimiento CreateProgressForm;
procedimiento ButtonClick(Remitente: TObject);
Función ConnectToExcel: Booleana;
procedimiento ExportDBGrid;
{Declaraciones privadas}
protegido
{ Declaraciones protegidas }
público
Constructor Crear(AOwner: TComponent);
Destructor Destruir(); anular;
Procedimiento ExportToExcel; {Exportar cuadrícula a Excel}
{Declaraciones públicas}
publicado
{ Declaraciones publicadas }
propiedad DBGrid: TDBGrid lee FDBGrid escribe FDBGrid;
Título de propiedad: Cadena lee FTitle escribe FTitle;
propiedad ShowProgress: lectura booleana FShowProgress escritura SetShowProgress;
propiedad OnProgress: TNotifyEvent lee FOnProgress escribe FOnProgress;
fin;
Registro de trámites;
implementación
Registro de trámites;
comenzar
RegisterComponents('Muestras', [TDBGridToExcel]);
fin;
{TDBGridToExcel}
procedimiento TDBGridToExcel.ButtonClick(Remitente: TObject);
comenzar
Salir := MessageBox(ProgressForm.Handle, pchar(SConfirm), pchar(SCaption),
MB_OKCANCEL + MB_ICONINFORMATION) = IDOK;
fin;
función TDBGridToExcel.ConnectToExcel: booleana;
comenzar
Resultado := verdadero;
Intentar
ExcelApp := CreateOleObject('Excel.aplicación');
ExcelApp.Visible := Falso;
si Título<>'' entonces ExcelApp.Caption := Título;
ExcelApp.WorkBooks.Agregar;
excepto
MessageBox(GetActiveWindow,PChar(SConnectExcelError),PChar(SError),Mb_OK+MB_IconError);
resultado := falso;
fin;
fin;
constructor TDBGridToExcel.Create(AOwner: TComponent);
comenzar
heredado;
FShowProgress := True; {El valor predeterminado era Mostrar el progreso}
FAutoSalida := Falso;
FAutoSize := Verdadero;
fin;
procedimiento TDBGridToExcel.CreateProgressForm;
var
Panel: Panel T;
Botón: TBotón;
comenzar
si está asignado (ProgressForm), salga {¿Está listo para crear?}
ProgressForm := TForm.Create(Propietario);
Con ProgressForm hazlo
comenzar
Fuente.Nombre := '宋体';
Tamaño de fuente: = 10;
Estilo de borde := bsNinguno;
Ancho := 280;
Altura := 120;
Ancho del borde: = 1;
Color := clFondo;
Posición := poOwnerFormCenter;
fin;
Panel := TPanel.Create(ProgressForm);
con Panel hacer {Crear Panel}
comenzar
Padre := ProgressForm;
Alinear := alClient;
BiselInner := bvNinguno;
BevelOuter: = bvRaised;
Título := '';
fin;
Mensaje := TLabel.Create(Panel);
con el mensaje hacer {Crear etiqueta}
comenzar
Padre := Panel;
Izquierda := 20;
Arriba := 25;
Título: = SConnectExcel;
fin;
Barra de progreso := TProgressBar.Create(panel);
con ProgressBar haga {Crear ProgressBar}
comenzar
Paso := 1;
Padre := Panel;
Suave := verdadero;
Izquierda := 20;
Arriba := 50;
Altura: = 18;
Ancho := 260;
fin;
Botón := TButton.Create(Panel);
con el botón hacer {Crear botón Cancelar}
comenzar
Padre := Panel;
Izquierda := 115;
Arriba := 80;
Título := SCancelar;
Al hacer clic := Hacer clic en el botón;
fin;
Formulario de progreso.Mostrar;
ProgressForm.Actualización;
fin;
destructor TDBGridToExcel.Destroy;
comenzar
heredado;
fin;
procedimiento TDBGridToExcel.ExportDBGrid;
var
Datos: TDataSet;
ADBGrid: TDBGrid;
i, j: número entero;
PuntoActual: Puntero;
OldBeforeScroll, OldAfterScroll: TDataSetNotifyEvent;
comenzar
Pantalla.Cursor := crHourGlass;
intentar
intentar
TForm(Propietario).Habilitado:= Falso;
ExcelApp.DisplayAlerts: = falso;
ExcelApp.ScreenUpdating: = falso;
Salir := falso;
si ShowProgress entonces Prompt.Caption := SPromptExport;
ADBGrid := DBGrid;
Datos := ADBGrid.DataSource.DataSet;
con ADBGrid hacer {Insertar encabezado de tabla}
para i: = 1 a Columns.Count hacer
si columnas [i - 1]. Visible entonces
ExcelApp.Cells[1,i].Valor :=Columnas[i - 1].Título.Caption;
CurrentPoint := Data.GetBookmark; {Guardar posición actual}
OldBeforeScroll: = Data.BeforeScroll; {Guardar antiguo antes del identificador del evento de desplazamiento}
OldAfterScroll: = Data.AfterScroll; {Guardar identificador de evento antiguo AfterScroll}
Data.DisableControls; {Desactivar control}
Datos.BeforeScroll:= nil;
Datos.AfterScroll: = nulo;
si ShowProgress entonces ProgressBar.Max := Data.RecordCount;
yo := 2;
Datos.Primero;
mientras que no Data.Eof do {Procesar todo el registro}
comenzar
con ADBGrid hacer {Procesar un registro}
para j: = 1 a Columns.Count hacer
si Columnas [j - 1]. Visible entonces
ExcelApp.Cells[i,j].Value := Columnas[j - 1].Field.DisplayText;
Inc(yo);
Datos.Siguiente;
si está asignado (FOnProgress), entonces FOnProgress (Self);
si ShowProgress entonces {Actualizar interfaz de usuario de progreso}
comenzar
Barra de progreso.StepIt;
Aplicación.ProcessMessages;
si sale, salga;
fin;
fin;
excepto
MessageBox(GetActiveWindow,PChar(SConnectExcelError),Pchar(SError),MB_OK+MB_ICONERROR);
fin;
ExcelApp.Visible := Falso;
TForm(Propietario).Habilitado:= Verdadero;
Pantalla.Cursor := crDefault;
si ShowProgress entonces FreeAndNil(ProgressForm); {Formulario de progreso gratuito}
ExcelApp.DisplayAlerts:= Verdadero;
ExcelApp.ScreenUpdating:= Verdadero;
finalmente
Data.BeforeScroll: = OldBeforeScroll; {Restaurar identificador de evento anterior}
Datos.AfterScroll: = OldAfterScroll;
Datos.GotoBookmark(CurrentPoint);
Datos.FreeBookmark(CurrentPoint);
Datos.EnableControls;
Pantalla.Cursor := crDefault;
fin;
fin;
procedimiento TDBGridToExcel.ExportToExcel;
comenzar
si DBGrid = nil entonces genera Exception.Create(SGridError); {No DataSource, luego Error}
si ShowProgress entonces CreateProgressForm {Si muestra o no el ProgressForm}
si no es ConnectToExcel, entonces {Salir cuando se produzca un error}
comenzar
si ShowProgress entonces FreeAndNil(ProgressForm);
salida;
fin;
ExportDBGrid; {comenzar Exportar datos}
fin;
procedimiento TDBGridToExcel.SetShowProgress (valor constante: booleano);
comenzar
FShowProgress := Valor;
fin;
fin.