Zwei Fragen zu Komponentenentwicklung

[DGL-luke]

Einleitend:
Sollte es hier keine extra Sparte für Komponentenentwicklung geben? denn ich habe erstens nich keine wirklich hilfreichen Komponententuts(wobei ich das auf dsdt da nicht dazuzähle. sowas kann ich auch ohne tut.) gefunden.
es gibt ja in der OS-Sparte immer wieder Komponenten zum Download.

Meine Fragen:

- Ich will meine Komponenten richtig zeichnen lassen, auch zur designtime. muss ich dazu nur die bereits vorhandene paint-methode überschreiben, und der rest geht automatisch?

- Wie bringe ich den Konstruktor in den OI, bzw. wie lege ich Standardwerte fest, die der OI überschreiben kann? ich habe bis jetzt immer im create der komponente die standardwerte belegt, wenn ich dann im OI etwas geändert habe scheint das keine auswirkungen gehabt zu haben, sondern ich musste die Initialisierung immer im formcreate machen.

danke schonmal für die sicher hilfreichen antworten. für wirkich tiefergehende tutorials bin ich immer dankbar!

EDIT: topic konkretisiert.

EDIT: aufgrund neuer sachlage obige aussage revidiert.

[jfheins]

Was möchtest du denn für eine Komponente machen ?

[Hansa]

Zitat von DGL-luke:

...wobei ich das auf dsdt da nicht dazuzähle. sowas kann ich auch ohne tut.)...wie lege ich Standardwerte fest, die der OI überschreiben kann?

"Kann ich sowieso", das behaupten einige andere auch und scheitern erbärmlich. Ist es dir wenigstens schon gelungen eine erweiterte Eigenschaft irgendwo im OI einer einfachen Komponente unterzubringen ? Da nach deiner Aussage der OI Standartwerte "Überschreiben" soll, glaube ich das nämlich nicht so recht. 8)

Also : liefere Source-Teile oder zumindest Screenshot. Wie soll sonst jemand was dazu sagen ?

[phlux]

Ich schließe mich Hansa an, wenn du sagst das du alls von dsdt kannst dann frag ich mich wieso du solche fragen fragst wenn sie doch dort im tutorial geklärt werden

Fragen zur Komponentenentwicklung habe ich immer in die VCL Sparte gepostet und da passen sie wohl auch sinngemäß rein finde ich, also wäre eine neue sparte für komponentenentwicklung irgendwie unnütz

[DGL-luke]

um missverständnisse zu vermeiden: ich habe bereits eine komponente programmiert, die soweit auch funktioniert.


ich hab da auch eine procedure paint; , die allerdings nix überschreibt, sondern von formpaint aufgerufen wird.

um meine aussage also ein wenig zu entschärfen:

"so weit wie das tutorial auf dsdt bin ich auch schon".

@phlux: ich habe in der suche gesehen, dass die threads zu komponenten ziemlich gleichmässig auf "sonstige fragen zu delphi" und "vcl und controls" verteilt sind. wenn man streng ist, passen eigene komponetenten auch nicht wirklich in die VCL-Sparte: "Fragen rund um VCL- und WinForms-Komponenten einschließlich der Common Controls(z.B. deren Benutzung und/oder Weiterentwicklung)" - gehören selbst entwickelte Komponenten zur VCL?!

@jfheins: eine processbar, die auf ein canvas gezeichnet wird anstatt sich selbst zu zeichnen, da ich überprüfen möchte, ob das bei einer großen anzahl von progressbars performancevorteile bringt.

der komplette source(hab gerade keine zeit, das hochzuladen):

Delphi-Quellcode:

unit U_CanvasBar;

interface

uses Graphics,Types,SysUtils,Classes,Windows;

type TCanvasbar = class(TComponent)
 private
  fStep,FPercent,fPosition:integer;
  fMin,fMax:integer;
  fLeft,fTop,fWidth,fHeight:integer;
  fParent:TCanvas;
  fBorderCol,fColor,fGaugeCol:TColor;
  fFont:TFont;
  procedure SetPosition(value:integer);
 public
   constructor Create(AOwner:TComponent); override;
   destructor  Destroy; override;

   procedure Paint; //kein override, sollte da eins sein?
   procedure StepIt;
 published
  property Parent  : TCanvas read fParent write fParent;
  property Step    : integer read fStep    write fStep       ;   //stored 1;
  property Position: integer read fPosition write SetPosition;   //stored 0;
  property Percent : integer read fPercent                   ;   //stored 0;
  property Left    : integer read fLeft write fLeft          ;   //stored 0;
  property Top     : integer read fTop write fTop            ;   //stored 0;
  property Height  : integer read fHeight write fHeight      ;   //stored 0;
  property Width   : integer read fWidth write fWidth        ;   //stored 0;
  property BorderColor: TColor read fBorderCol write fBorderCol; //stored clblack;
  property Color: TColor read fColor write FColor              ; //stored clgray;
  property FGaugeColor:TColor read fGaugeCol write fGaugeCol   ; //stored clmedgray;
  property Font: TFont read fFont write fFont;
  property Min: integer read fMin write fMin;
  property Max: integer read fmax write fMax;

end;

procedure Register;

implementation

procedure Register;
begin
RegisterComponents('Custom',[TCanvasBar]);
end;

constructor TCanvasBar.Create(AOwner:TComponent);

begin
 inherited;
  fBorderCol := clBlack;  //hier werden die angesprochenen standardwerte gesetzt, die ich im OI nicht überschrieben kann.
  fGaugeCol  := clSilver; //im OI erscheint das hier übrigens auch als clblack....
  fColor       := clGray; //...ebenso wie das hier.
  fFont:=TFont.Create;
  fMin:=0;
  fMax:=100;
  fPosition:=0;
  fPercent:=0;
  fStep:=1;
  fWidth:=160;
  fHeight:=16;
end;

destructor TCanvasBar.Destroy;
begin
 inherited;
 fFont.Free;
end;

procedure TCanvasBar.Paint;
var storpen:TPen;
    storbrush:TBrush;
    storfont:TFont;
    gaugerect:TRect;
    textwidth, textHeight, textLeft,textTop:integer;
begin
 storpen:=TPen.Create;
 storbrush:=TBrush.Create;
 storfont:=TFont.Create;
 storpen.Assign(fparent.pen);
 storbrush.Assign(fparent.Brush);
 storfont.Assign(fparent.Font);
 fparent.Pen.Color:=fBorderCol;
 fparent.Brush.Color:=fColor;

 fparent.Rectangle(fleft,ftop,fleft+fwidth,ftop+fheight);

if fPercent > 0 then
begin
 GaugeRect.Left:=fLeft+1;
 GaugeRect.Top:=fTop+1;
 GaugeRect.Bottom:=fTop + fHeight - 1;
 GaugeRect.Right:= fLeft + round( (fwidth-2) * ( fPosition / fMax ));
 fparent.Pen.Color:=fGaugeCol;
 fparent.Brush.Color:=fGaugeCol;

 fparent.Rectangle(GaugeRect);
end;

 fparent.Font:= fFont;
 textwidth  := fparent.TextWidth(inttostr(fPercent)+'%');
 textHeight := fparent.TextHeight(inttostr(fPercent)+'%');
 textLeft := round(fLeft + fWidth  / 2 - textWidth  / 2);
 textTop  := round(fTop + fHeight / 2 - textHeight / 2);

 SetBKMode(parent.Handle,TRANSPARENT); //das geht eleganter, ich weiss.
 fparent.TextOut(textLeft,textTop,inttostr(fPercent)+'%');
 SetBKMode(parent.Handle,OPAQUE);

 fparent.Brush.Assign(storbrush);
 fparent.Pen.Assign(storpen);
 fparent.Font.Assign(storfont);

 storpen.Free;
 storbrush.Free;
 storfont.Free;

end;

procedure TCanvasBar.StepIt;
begin
fPosition  := fPosition+fStep;
self.SetPosition(fPosition);

Paint;
end;

procedure TCanvasbar.SetPosition(value:integer);
begin
fPosition := value;
if fMin <> fMax then
fPercent  := Round(Abs((fPosition - fMin) / (fMax - fMin)) * 100)
else fPercent:=0;
end;
end.

ein screenshot kommt vielleicht später, ich hab auf jeden fall ne test-app da.

EDIT: aufgrund neuer sachlage obige aussage revidiert.

[xaromz]

Hallo,

ein paar Kleinigkeiten:

Du verwendest als Eigenschaft Parent. Eine Komponente hat schon eine solche Eigenschaft. Benutze lieber einen anderen Namen.

Delphi-Quellcode:

destructor TCanvasBar.Destroy; 
begin 
inherited; 
fFont.Free; 
end;

inherited kommt im Destructor immer am Schluss!

Die Methode Paint solltest Du entweder überschreiben, damit sie automatisch aufgefufen wird oder umbenennen, um die ursprüngliche Methode zu behalten.

Gruß
xaromz

[Hansa]

Zitat von DGL-luke:

um meine aussage also ein wenig zu entschärfen:

"so weit wie das tutorial auf dsdt bin ich auch schon".

Durch den Quelltext ist meine Vermutung aber eher verschärft worden. Du behandelst doch die Properties fast wie normale Variablen ! Und so geht es eben nicht. Woher soll denn der arme OI wissen, daß du da eine Farbe ändern (ja überschreiben ist was anderes) willst ? Du hast ihn doch kompett auf clBlack festgelegt.

Mehr zu sagen bringt jetzt auch nicht viel. Lese dir das Tuto nochmals durch, aber dann lese auch jedes Wort und suche dir besser eine andere Komponente um zu üben ! Also eine, die schon was mitbringt. Du fängst ja fast schon bei Adam und Eva an. Und das hat mit OOP nicht mehr viel zu tun.

[phlux]

ja sicher musst du override; dahinterschreiben wenn du die prozedure überschreiben willst und nicht vergessen in der prozedur paint dann selbst am ende noch inherited paint; zu schreiben

[DGL-luke]

@xaromz: hätt ich mir eigentlich irgendwie denken können, dass eine komponente schon ein parent hat
wie greif ich dann darauf zu, und wie zwinge ich den progger, dass er ein canvas als parent nimmt?
oder soll ich schauen, ob das parent ein canvas hat?

das mit dem destruktor ist auch logisch. danke.

@Hansa: hmm... vielleicht hast du recht. werde mir das nochmal durchlesen. und das mit dem OI: ich sehe nicht, wo ich den OI "festlege". TColor ist TColor. Und der OI soll das dann gefälligst nach meinen einstellungen anpassen.

@phlux: k, mach ich.

PS: großes "ÖHA"! da(dsdt) gibts ja zwei tuts zur komponentenentwicklung Damit muss ich natürlich die aussage ganz zurücknehmen.

[Hansa]

Zitat von DGL-luke:

TColor ist TColor. Und der OI soll das dann gefälligst nach meinen einstellungen anpassen.

Das wird er aber nicht tun. Der hört nicht auf dich. 8) Der ist eben zu dumm. Du hast ihm auch nur lediglich gesagt, er hätte irgendwo ein TColor. Wie kommst du darauf, der käme ganz von alleine auf die Idee, daß du das tatsächlich mal einstellen willst ? Ja, der ist tatsächlich nicht nur dumm, sondern sogar faul.

Aber du hast ja zumindest eingesehen, das Tuto neu lesen zu müssen. Deshalb noch ein Hinweis : könnte es sein, daß sich die "Position" einstellen läßt ? Wenn dem so ist, dann gucke dir mal alles damit zusammenhängende neu an. Auch in dem Tuto.