Komponenten mit dem Komponentenexperten erzeugen
Nach oben zu Neue Komponenten erzeugen
Der Experte Neue Komponente vereinfacht die Entwicklung von neuen Komponenten. Für den Experten Neue Komponente müssen Sie Werte für folgende Einstellungen angeben oder akzeptieren:
- Die Personality (Delphi oder C++) (Win32 ist die einzige Auswahlmöglichkeit für das Framework/die Plattform)
- Die Klasse, von der die Komponente abgeleitet wird
- Den Klassennamen der neuen Komponente
- Die Kategorie der Tool-Palette, in der die neue Komponente angezeigt werden soll
- Den Namen der Unit, in der die Komponente erzeugt wird
- Den Suchpfad der Unit
- Den Namen des Package, das die neue Komponente enthalten soll
Der Experte Neue Komponente führt dieselben Aufgaben durch wie Sie selbst, wenn Sie eine Komponente manuell erzeugen:
- Erzeugen einer Unit
- Ableiten der Komponente
- Registrieren der Komponente
So fügen Sie eine neue Komponente mit dem Experten Neue Komponente hinzu
- Sie können den Experten Neue Komponente auf zwei Arten aufrufen:
- Wählen Sie Komponente > Neue Komponente.
- Wählen Sie Datei > Neu > Weitere, wechseln Sie zur Seite Delphi-Projekte > Delphi-Dateien, und doppelklicken Sie auf Komponente.
Hinweis: Der über den Befehl Datei > Neu > Weitere gestartete Experte kann einer vorhandenen Unit keine Komponenten hinzufügen. Komponenten müssen Sie vorhandenen Units manuell hinzufügen.
- Geben Sie in die Felder des Experten Neue Komponente die folgenden Informationen ein.
- Wählen Sie auf der Seite Personality, Framework und Plattform den Typ für die zu erstellende Komponente aus: Delphi oder C++. (Wenn in der IDE ein Projekt geöffnet ist, wird die Personality dieses Projekts verwendet.)
- Wählen Sie auf der Seite Vorfahrkomponente die Klasse aus, von der die neue Komponente abgeleitet werden soll.
- Geben Sie auf der Seite Komponente den Namen der neuen Komponentenklasse in das Feld Klassenname ein.
- Geben Sie im Feld Palettenseite die Kategorie der Tool-Palette an, in die die neue Komponente installiert werden soll.
- Geben Sie im Feld Unit-Dateiname den Namen der Unit an, in der die neue Komponentenklasse deklariert werden soll. Wenn sich die Unit nicht im Standardsuchpfad befindet, bearbeiten Sie den Eintrag im Feld Suchpfad.
- Klicken Sie nach dem Ausfüllen aller Felder im Experten Neue Komponente auf Fertig stellen. Um die Komponente in ein neues oder ein vorhandenes Package einzufügen, wählen Sie Komponente > Installieren und geben im angezeigten Dialogfeld ein Package an.
- Klicken Sie auf OK. Die IDE erzeugt eine neue Unit.
Warnung: Wenn Sie eine Komponente von einer Klasse ableiten, deren Name mit "TCustom" beginnt (z. B. TCustomControl), dürfen Sie die neue Komponente nicht in einem Formular platzieren, bevor Sie nicht alle abstrakten Methoden der Originalkomponente überschrieben haben. Delphi kann keine Instanzen einer Klasse erzeugen, die abstrakte Methoden oder Eigenschaften enthält.
Delphi erzeugt eine neue Unit, die die Klassendeklaration und die Prozedur Register enthält, und fügt sie der uses-Klausel hinzu, mit der alle Standard-Units von Delphi eingebunden werden. Um den Quellcode der Unit im Quelltext-Editor anzuzeigen, wählen Sie Ansicht > Units..., oder öffnen Sie die Unit-Datei im Quelltext-Editor durch Auswahl von Datei > Öffnen.
Die Unit sieht etwa wie folgt aus:
unit MyControl;
interface
uses
Windows, Messages, SysUtils, Types, Classes, Controls;
type
TMyControl = class(TCustomControl)
private
{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
published
{ Published declarations }
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Samples', [TMyControl]);
end;
end.
//header file
#ifndef NewComponentH
#define NewComponentH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Controls.hpp>
#include <Classes.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class PACKAGE TNewComponent : public TComponent
{
private:
protected:
public:
__fastcall TNewComponent(TComponent* Owner);
__published:
};
//---------------------------------------------------------------------------
#endif
//implementation file
#include <vcl.h>
#pragma hdrstop
#include "NewComponent.h"
#pragma package(smart_init);
//---------------------------------------------------------------------------
// ValidCtrCheck is used to assure that the components created do not have
// any pure virtual functions.
//
static inline void ValidCtrCheck(TNewComponent *)
{
new TNewComponent(NULL);
}
//---------------------------------------------------------------------------
__fastcall TNewComponent::TNewComponent(TComponent* Owner)
: TComponent(Owner)
{
}
//---------------------------------------------------------------------------
namespace Newcomponent
{
void __fastcall PACKAGE Register()
{
TComponentClass classes[1] = {__classid(TNewComponent)};
RegisterComponents("Samples", classes, 0);
}
}