vom Objekt zur Komponente

[sebi87]

Hallo Delphi-Gemeinde,

wie erstelle ich aus einem Objetkt das in einer eigenen Unit steht eine Komponente?


Schn jetzt mal danke für eure Hilfe.


Sebastian

[RavenIV]

Zu diesem Thema fleigt hier irgendwo ein Tutorial rum

Such mal nach "Tutorial Komponenten" hier im Forum.

[mkinzler]

http://www.delphi-treff.de/tutorials...n/katalog/174/
http://www.delphi-treff.de/tutorials...n/katalog/174/

[sebi87]

Danke für den Tipp, das ist genau das was ich gesucht habe.

[sebi87]

So das hat jetzt alles wunderbar funktioniert jetzt hab ich noch das Problem das ich im meinem Objekt eine Create-Construktor in dem ich einen Punkt und eine Canvas übergebe und ich nicht nicht weiß wie ich das in die Komponente einbinde.

hier mal der Kopf:

Delphi-Quellcode:

constructor Create(AMittelpunkt : TPoint; ACanvas : TCanvas; AVolumen : real) ;

Sebastian

[mkinzler]

Was meinst du mit Einbinden? Implementieren? Aufrufen?

[Muetze1]

Den Constructor darfst du nicht neu implementieren, nur überschreiben. Ansonsten kann deine Komponente nicht als solches verwendet werden, da dein Konstruktor beim Streaming nie aufgerufen wird. Auch erbst du im Normalfall einen Canvas, somit ist die Übergabe über den Constructor absolet.

[sebi87]

OK, ich überschreibe den Construktor.

Wenn ich jetzt das Objekt aufrufe, z.B.

Delphi-Quellcode:

Test := TBall.Create(Canvas, Point) ;

dann kann ich die Procedure Paint des Objects aufrufen, also

Delphi-Quellcode:

Test.Paint ;

Und der Ball wird auf die Canvas um den Punkt Point gezeichnet.

Dies möchte ich jetzt mit der Komponente machen, nach den Erstellen soll die Procedure Paint zur verfügung sehen und die Vorher angegebene Canvas und Point sollen als Zeichengrundlage dienen.


Sebastian

[mkinzler]

Von welcher Klasse erbt TBall?

[sebi87]

TBall erbt von TComponent.

[mkinzler]

Delphi-Quellcode:

TBall = class(TComponent)
  private
    FCanvas: TCanvas;
    FPoint: TPoint;
  public
    constructor Create(AOwner: TComponent); overload; override; // Standard-Constructor Eigentlich nicht unbedingt notwendig, aber ich würde ihn trotzdem anlegen
    constructor Create(AOwner: TComponent; Acanvas: TCanvas; APoint: TPoint ); overload;
    procedure Paint;
  published
    property Canvas: TCanvas read FCanvas write FCanvas;
    property Point:  TPoint  read FPoint  write FPoint;
end;

...

constructor TBall.Create( AOwner: TComponent);
begin
    inherited create (AOwner); //geerbter Konstruktor
    FCanvas := Nil; //Zur Sicherheit
    FPoint := Nil;  //Zur Sicherheit;
end;

constructor TBall.Create(AOwner: TComponent; ACanvas: TCanvas; APoint: TPoint ); 
begin
    Create( AOwner); // Aufruf Standardkonstruktor
    FCanvas := ACanvas;
    FPoint := APoint;
end;
...

was willst du eigentlich mit diesem Konstrukt erreichen? bitte beachten, dass du dich auch darum kümmern musst, dass deine Paint-Methode aufgerufen wird, wenn der externe Canvas neu gezeichnet wird.

[sebi87]

Was will ich damit erreichen?

Na ja ich will mir das Zeichen von "Bällen" also Kugeln durch eine Komponente vereinfachen da ich das in der "Anwendung" also meinem Arbeitskreis sehr oft benötige.


Danke für die schnelle Antwort, ich werde das mal versuchen.


Sebastian

[SirThornberry]

wenn du eine visuelle Componente willst solltest du TCustomControl oder TGraphicControl verwenden je nach dem was du genau vor hast. Dort gibt es bereits eine Canvas und die Implementierung für das Zeichnen, Fenster allocieren etc. ist auch vorhanden. Es macht ja keinen sinn eine nicht visuelle Komponente zu verwenden wenn sie etwas visuell darstellen soll.

[sebi87]

funktionier jetzt alles soweit nur bei

Delphi-Quellcode:

FPoint := Nil;

erscheint immer ein Kompatibilitätsfehler

[mkinzler]

Oh TPoint ist ein Record keine Klasse:

Delphi-Quellcode:

FPoint.x := -1;
FPoint.y := -1;

[sebi87]

So geht jetzt alles ganz wunderbar.

Nur hab ich schon wieder ein Problem an dem ich jetzt nicht weiter komme.

Ich will in dem Construktor beim "ertellen" der Komponente ein Objekt "erstellen"
ich hab das jetzt einfach so versucht

Delphi-Quellcode:

constructor TBall.Create(AOwner : TComponent; AMittelpunkt : TPoint; Canvas : TCanvas) ;
begin
  Create(AOwner) ;

  FCanvas := ACanvas ;
  FMittelpunkt := AMittelpunkt ;

  Dreieck:= TVieleck.Create ;
end ;

wenn ich das Objekt benutzen will, stoße ich aber immer auf eine Zugriffsverletzung im Projekt, hat jemanden ne Idee wie das Funktioniert?

[mkinzler]

Wo hast du das Objekt Dreieck definiert? BTW. Das würde ich im Standard-Konstruktor instantiieren.

[DeddyH]

Ich steig da nicht durch: Canvas, ACanvas und FCanvas?

[sebi87]

Ok, im Standart-Konstruktor schieben ist kein Problem.

Das Objekt ist in der gleichen Unit definiert

[sebi87]

@ DeddyH:

Stimmt das ist ein fehler drin muss so heißen:

Delphi-Quellcode:

constructor TBall.Create(AOwner : TComponent; AMittelpunkt : TPoint; ACanvas : TCanvas) ;
begin
  Create(AOwner) ;

  FCanvas := ACanvas ;
  FMittelpunkt := AMittelpunkt ;

  Dreieck:= TVieleck.Create ;
end ;

und ACanvas wird an FCanvas die Global deiniert ist übergeben

[mkinzler]

Zitat:

Das Objekt ist in der gleichen Unit definiert

Unit oder Klasse?

[sebi87]

also der Type-Teil ist in der gleichen Unit und die Variable ist dann in der Klasse

muss es in die Klasse ;

[mkinzler]

Das würde sich sehr anbieten.

[sebi87]

dann müsste ich eine Klasse TObject in der Klasse TComponent definieren.

geht das?

[mkinzler]

Ich redete von der Variablen Dreieck und nicht der Klasse TVieleck

[sebi87]

OK, hab ich jetzt falsch verstanden.

Die Variable Vieleck ist in der Kalsse, das schon

[mkinzler]

Zeig mal die komplette Unit.

[sebi87]

Hier mal ein Teil

Delphi-Quellcode:

unit C_Ball_V2;

{- [ITNERFACE]-Teil -----------------------------------------------------------}
interface

uses Windows, Classes, Graphics ;

function PointEllipse(Mittelpunkt : TPoint ; Winkel, ARadius : integer;
 BRadius : integer = 0) : TPoint ;
function PointBezier(A, B, C, D : TPoint; Teilung, Schritt : Integer) : TPoint ;

type
{- Typendefinierung -----------------------------------------------------------}
  TSite = (lsLeft, lsRight) ;
  TPaintStyle = (psLine, psColored) ;


{- TVieleck -------------------------------------------------------------------}
  TVieleck = class
  // [PRIVATE]-Teil
  private
    Mittelpunkt : TPoint ;
    FVieleck : array of TPoint ;
    Canvas : TCanvas ;

  // [PUBLIC]-Teil
  public
    constructor Create(AMittelpunkt : TPoint; ACanvas : TCanvas) ;
    procedure Paint(AColor : TColor) ;
  end ;

{- TBall ---------------------------------------------------------------------}
  TBall = class(TComponent)
  // [PRIVATE]-Teil
  private
    FMittelpunkt : TPoint ;
    FCanvas      : TCanvas ;
    Dreieck      : TVieleck;

    FPaintStyle  : TPaintStyle ;
    FbgColor     : TColor ;
    FLineColor   : TColor ;

  // [PUBLIC]-Teil
  public
    constructor Create(AOwner : TComponent) ; overload; override;  // Standard-Construktor
    constructor Create(AOwner : TComponent; AMittelpunkt : TPoint;
      ACanvas : TCanvas) ; overload;
    procedure Paint ;
    procedure Clear ;
    procedure Repaint ;

  // [POTECTED]-Teil
  protected

  // [PUBLISHED]-Teil
  published
    property Canvas : TCanvas read FCanvas write FCanvas ;
    property XMittelpunkt : Integer read FMittelpunkt.x write FMittelpunkt.x ;
    property YMittelpunkt : Integer read FMittelpunkt.y write FMittelpunkt.y ;

    property PaintStyle : TPaintstyle read FPaintStyle write ChangePaintStyle ;
    property bgColor : TColor read FbgColor ;
    property LineColor : TColor read FLineColor ;
  end ;

procedure Register;

{- [IMPLEMENTATION]-Teil ------------------------------------------------------}
implementation

procedure Register;
begin
  RegisterComponents('Ball', [TBall]);
end;


{- TVieleck -------------------------------------------------------------------}

// Generiert TVieleck auf ACanvas mit AMittelpunkt
constructor TVieleck.Create(AMittelpunkt : TPoint; ACanvas : TCanvas) ;
begin
  inherited Create;
  Canvas := ACanvas ;
  Mittelpunkt := AMittelpunkt ;
end ;

// Erstellt TVieleck aus den Daten
procedure TVieleck.Paint(AColor : TColor) ;
begin
  Canvas.Pen.Width := 2 ;
  Canvas.Pen.Color := AColor ;
  Canvas.Polyline(FDreieck) ;
end ;

{- TBall ----------------------------------------------------------------------}
// Standard-Constructor
constructor TBall.Create(AOwner : TComponent) ;
begin
  inherited Create(AOwner);   // geerbter Konstruktor
  FCanvas := nil ;            // Zur Sicherheit
  FMittelpunkt.x := -1 ;      // Zur Sicherheit
  FMittelpunkt.y := -1 ;      // Zur Sicherheit

  Dreieck := TVieleck.Create(FMittelpunkt, FCanvas) ;
end ;

constructor TBall.Create(AOwner : TComponent; AMittelpunkt : TPoint;
  ACanvas : TCanvas) ;
begin
  Create(AOwner) ;
  // Standartwerte für Propertys
  FbgColor         := clWhite ;
  FLineColor       := clBlack ;
  FLungColor       := $008B82FF ;

  FCanvas := ACanvas ;
  FMittelpunkt := AMittelpunkt ;
end ;

// Zeichent
procedure TBall.Paint ;
begin
  Dreieck.Paint(FLineColor) ;
end ;

// Löschte
procedure TBall.Clear ;
begin
  Dreieck.Paint(FbgColor) ;
end ;

// Zeichnet neu
procedure TBall.Repaint ;
begin
  // Löschen
  Clear ;
  // Neuzeichnen
  Paint ;
end ;

[mkinzler]

Erst mal fällt auf, dass deine Bezeichnungen inkonsistent sind.
Suffix F für alle privaten Felder, Suffix A für Parameter, T für Typen
Aber da FDreieck von den Werten, anderer Felder abhängt, war der 2. Konstruktor doch richtig.

[sebi87]

ok abgesehen, dass meine Bezeichnungen inkonsistent sind weiß ich wo der Fehler liegt.

Zu dem Zeitpunkt wenn der Constructor ausgeführt wird ist das Canvas noch nil und auf ein nicht existierendes Canvas kann man nicht zeichnen.

[sebi87]

wie weiß ich der property Canvas von TBall eine Canvas zu?

[mkinzler]

Die property sollte FCanvas heissen und zuweisen tut ja mit

Delphi-Quellcode:

FCanvas := ACanvas;

[sebi87]

Schon, das passiert auch, nur hab ich die Zuweisung zu FCanvas an in dem Consturctor und ich weiß nicht wie ich hier die Canvas zuweise

Delphi-Quellcode:

   constructor Create(AOwner : TComponent; AMittelpunkt : TPoint;
      ACanvas : TCanvas) ; overload;

  // [PUBLISHED]-Teil
  published
    property Canvas : TCanvas read FCanvas write FCanvas ;



 constructor TBall.Create(AOwner : TComponent; AMittelpunkt : TPoint;
      ACanvas : TCanvas);
  begin
   FCanvas := ACanvas ;
  end ;

Danke

[DeddyH]

Du musst den Canvas vor dem Erzeugen Deines Objektes anlegen und dann im Konstruktor übergeben.