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:

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. :lol: 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 :roll:

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 :gruebel:

[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. :stupid:

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:

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. :lol: 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 :roll:
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 :shock: Damit muss ich natürlich die aussage ganz zurücknehmen. :oops:

[Hansa]

Zitat:

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. :lol: 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. :mrgreen:

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.

[xaromz]

Hallo,

ich muss mich korrigieren, TComponent hat kein Parent, das gibt's erst bei TControl :oops: .

Zitat:

Zitat von DGL-luke

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?

Auf welchen Canvas möchtest Du zeichnen?
Da Du von TComponent ableitest, hat Deine Komponente keinen Canvas und keine Paint-Mathode zum Überschreiben.
Du solltest also von TGraphicControl ableiten, da hast Du einen Canvas und eine Paint-Methode.
Ich hab mal Dein Zeug etwas überarbeitet, fehlt aber noch Werteüberprüfung.

@Hansa: Natürlich erkennt der OI ein TColor, wenn die Eigenschaft als Published deklariert ist.

Gruß
xaromz

[DGL-luke]

@xaromz: der clou des ganzen ist ja, dass die komponente sich nicht selbst zeichnet, sondern auf das parent-canvas gezeichnet wird.

den code werd ich mir aber morgen erst zu gemüte führen.

@Hansa: es käme mir wirklich extrem dumm vor, wenn der OI nicht wüsste, wohin er die werte schreiben soll, wenn ich ihm sowohl read als auch write definiert habe.

[jfheins]

Zitat:

Zitat von DGL-luke

@xaromz: der clou des ganzen ist ja, dass die komponente sich nicht selbst zeichnet, sondern auf das parent-canvas gezeichnet wird.

Du wirst es nicht glauben, aber afaik ist das auch so, wenn du überhaupt nichs machst :mrgreen:

(Nur muss es halt nicht mit Canvas passieren, sondern kann auch etwas effizienter sein ;) )

[Hansa]

Zitat:

Zitat von xaromz

@Hansa: Natürlich erkennt der OI ein TColor, wenn die Eigenschaft als Published deklariert ist.

Das brauchst du mir nicht zu sagen. Allerdings halte ich nicht viel von fertigen Lösungen. 8) Das ist nicht gut und hält manchen nur davon ab, sich selber was beizubringen, obwohl Defizite offensichtlich und auch genügend Hinweise da sind. Wo kommen wir denn hin, wenn jeder, der einem anderen helfen will, dem Fragesteller, der was lernen will, komplett die Arbeit abnimmt ? :roll:

[xaromz]

Hallo,

Zitat:

Zitat von Hansa

Allerdings halte ich nicht viel von fertigen Lösungen. 8) Das ist nicht gut und hält manchen nur davon ab, sich selber was beizubringen, obwohl Defizite offensichtlich und auch genügend Hinweise da sind. Wo kommen wir denn hin, wenn jeder, der einem anderen helfen will, dem Fragesteller, der was lernen will, komplett die Arbeit abnimmt ? :roll:

ich will ja hier niemandem die Arbeit abnehmen; ich denke aber, wenn man zeigt, wie es besser geht (ohne jetzt komplette Lösungen zu präsentieren), kann man schon eine Menge lernen. Auch ich habe, wie viele andere sicher auch, einen großen Teil meines Wissens erworben, indem ich mir fertige Lösungen angeschaut und analysiert habe. Wer meine Überarbeitung mit dem oben Geposteten vergleicht und die Unterschiede untersucht, wird vielleicht was lernen, und wenn er was nicht versteht, kann er ja fragen. Wie Du schon erkannt hast, gibt es hier einige Defizite, und ich kann ja nicht alles auf einmal erklären. Also soll er sich meine Version anschauen und dann gezielte Fragen stellen. Ich denke, das bringt mehr.

Zitat:

Zitat von DGL-luke

der clou des ganzen ist ja, dass die komponente sich nicht selbst zeichnet, sondern auf das parent-canvas gezeichnet wird.

Wozu ist eine graphische Komponente gut, wenn Sie nicht auf eine eigene Zeichenoberfläche zugreifen kann? :gruebel: Außer etwas Ressourcenschonung fällt mir da kein Grund ein. Insbesondere bei einer Progressbar scheint mir das etwas sinnlos.

Gruß
xaromz

[DGL-luke]

@Ressourcen: ich verweise mal auf den thread http://www.delphipraxis.net/internal...ct.php?t=54673 , wo sich jemand über meine ressourcenfressenden 128 RBProgressbars beschwert hatte:

Zitat:

Zitat von Velgreyer

Nur so als Tipp: Benutz Canvas und zeichne eine komplette Oberfläche mit der Auswertung, und nicht 127 Progressbars. Ich seh ja immer wie sich das ganze aufbaut wenn ich das Fenster in den Vordergrund nehme :shock:

Und das hier wollte ich eben als lösung des ganzen ausprobieren.

@Hansa: Du meinst also, wenn ich schon (Deiner meinung nach) absoluter Noob bin, darf man mir nicht wohlmeinend ein beispiel zeigen?
(Mir fällt auch sonst öfters auf, dass zu, sagen wir mal, ziemlich extreme Meinungen äusserst. vielleicht solltest du dir überlegen, ob du deinen ton nicht manchmal etwas mäßigen willst. Denn ein noob wie ich wird von so etwas wie "das behaupten einige andere auch und scheitern erbärmlich." eher abgeschreckt als wermutigtm, sich richtig reinzuhängen.)
Und ausserdem, wenn ich mich schon nicht von der meinung "wenn ich eine property mit read und write zugriff habe, kann der OI immer darauf zugreifen" abbringen lasse, hilft doch eigentlich nur noh quelltext, der das gegenteil beweist. Fakten fakten fakten! :mrgreen:

jetz schau ich mir aber erstmal den anhang von xaromz an.

EDIT: ich sehe, das ist jetzt von TGraphicControl abgeleitet. muss das denn sein? und auf welches canvas zeichnet es denn jetzt?

[Hansa]

Zitat:

Zitat von Hansa

Zitat:

Zitat von DGL-luke

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

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.

Das war ein Top-Hinweis, ohne für dich die ganze Arbeit zu machen. Völlig ausreichend um weiterzukommen. :!: Mit Verweis auf vorhandenen Source. Wenn du allerdings fertigen Source haben willst, dann sage das doch gleich vorher und beschwere dich nicht noch über Leute, die dir geholfen haben. 8)

P.S.: ehe ichs vergesse : die Frage wurde gestellt, ohne eine einzige Zeile Code dazu zu liefern ! Als Antwort erwartest du aber kompletten Code ? :shock:

[xaromz]

Hallo,

Zitat:

Zitat von DGL-luke

@Ressourcen: ich verweise mal auf den thread http://www.delphipraxis.net/internal...ct.php?t=54673 , wo sich jemand über meine ressourcenfressenden 128 RBProgressbars beschwert hatte:

Zitat:

Zitat von Velgreyer

Nur so als Tipp: Benutz Canvas und zeichne eine komplette Oberfläche mit der Auswertung, und nicht 127 Progressbars. Ich seh ja immer wie sich das ganze aufbaut wenn ich das Fenster in den Vordergrund nehme :shock:

Und das hier wollte ich eben als lösung des ganzen ausprobieren.

Jetzt kann ich das Ganze auch einordnen. Schneller wird der Bildaufbau mit meiner Lösung wohl nicht. Allerdings stellt sich die Frage, warum man das unbedingt beschleunigen muss, ich hab da schon schlimmeres gesehen. Die paar Millisekunden sollten egal sein.
Als Möglichkeit für Deine Bedürfnisse wäre evtl. eine Komponente (wieder von TGraphicControl) geeignet, die alle Werte aufnehmen und auf einmal anzeigen kann. Für das bisschen Zeitgewinn wäre das aber Overkill.

Zitat:

Zitat von DGL-luke

EDIT: ich sehe, das ist jetzt von TGraphicControl abgeleitet. muss das denn sein? und auf welches canvas zeichnet es denn jetzt?

Mit TGraphicControl hat die Komponente ihren eigenen Canvas. Sie malt quasi auf sich selbst.

Gruß
xaromz

[DGL-luke]

ja so hatt ich mir das gedacht. werde das ganze dann bei gelegenheit(hoffentlich noch dieses we) fertig proggen.

Hansa: Ein "top tip"? Du wirfst mir den brocken "position" hin, mit verweis auf ein tutorial, und das soll dann ein "top tip" sein? nein danke. im übrigen hab ich nie fertigen code verlangt, sondern zwei grundsätzliche, allgemeine und fast schon abstrakte fragen gestellt:

- wie lasse ich das paint-ereignis automatisch auslösen? Antwort: Paint überschreiben, fertig.
- wie bringe ich es so hin, dass ich die werte im OI einstellen kann? Antwort: ein wenig rumgedruckse, ein bisschen äusserst hinterfotzige ironie(war es ironie? so etwas sieht man in einem forum leider verdammt schlecht), aber sonst kaum etwas. nimm bitte nochmal alleine hierzu stellung:

"wenn ich eine property deklariere und mit read and write zugriff versehe, wie setze ich dann standardwerte? ich hatte das bis jetzt im konstruktor, wo es ja eigentlich auch hingehört, das scheint aber das, was ich im OI setze, zu überschreiben?"

mag sein, dass das im tutorial steht, aufgrund eines kleinen missgeschickes meinerseits(ja ich gebs ja zu) hab ich das aber nicht gelesen, obwohl ich selbiges vermeinte. ich werde es jetzt lesen, und vielleicht weiss ich dann schon weiter. ich würde es aber schon gerne noch sehen, dass du eine 1. eindeutige 2. anständige 3. hilfreiche antwort darauf zustande bringst. ansonsten würde es sich bei mir bestätigen, dass du gerne die anderen user ein wenig verarschst und oft postest ohne wirklich nachzudenken was genau du da postest.

([/@hansa])

EDIT: entweder bin ich schon zu müde, oder in dem tut steht wirklich nicht, wie ich standardwerte mache...

[phlux]

Standartwerte setzt du in dem du sie im Constructor überschreibst. Angenommen du hast eine selbst erstellte property Namens Padding, dann sieht der Code für die Compo so aus:

Delphi-Quellcode:

unit MyControl;

interface

uses
  Windows, SysUtils, Classes, Controls, Messages, Graphics;

type
  TMyControl= class(TCustomControl)
  private
    { Private-Deklarationen }
    fPadding: Integer;
  protected
    { Protected-Deklarationen }
    //procedure Paint; override;
  public
    { Public-Deklarationen }
    constructor Create(aOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Padding: Integer read fPadding write fPadding;
    // Vererbte Properties
    property Align;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Standard', [TMyControl]);
end;

constructor TMyControl.Create(aOwner: TComponent);
begin
  inherited Create(aOwner);
  fPadding := 5;  //Hier wird der Inhalt der Variable geändert
  Align := alLeft;   //Properties die du nicht selbst erstellt(vererbt) hast
                     //kannst du wie üblich ändern
end;

destructor TMyControl.Destroy;
begin
  inherited Destroy;
  fBackground.Free;
end;


(*
procedure TMyControl.Paint;
begin
  inherited Paint;
end;*)

end.

[DGL-luke]

das bedeutet also, der konstruktor wird schon ausgeführt, wenn ich die komponente aufs form setze, oder? (alles andere würde ja auch keinen sinn machen)

[phlux]

Klar ;) um herauszufinden ob du dich in der "DesignZeit" befindest oder zur Laufzeit musst du überprüfen ob csDesigning im Set von DesignTime ist.

[DGL-luke]

hmm... TComponent hat gar keine Methode paint; sprich ich kann gar nichts überschreiben. was mach ich jetzt?

ich will auf jeden fall nicht von etwas anderem ableiten.

[xaromz]

Hallo,

nur visuelle Komponenten haben die Methode Paint (TCustomControl, TGraphicControl). Deshalb hatte ich ja von TGraphicControl abgeleitet. Wenn Du eine Paint-Methode haben willst, musst Du wohl ein WM_PAINT Ereignis abfangen, und zwar von übergeordneten Control. Ansonsten musst Du Dir deinen eigenen DC besorgen. Da Du aber dann im Grunde ein TGraphicControl nachbauen musst ist es eigentlich sinnvoller, gleich das Original zu nehmen.

Gruß
xaromz

[DGL-luke]

nein, wenn ich schon nicht von TGraphicControl ableiten will, dann will ich es auch nicht nachbauen.

Wie bringe ich das Parent dann dazu, WM_PAINT an die komponente zu senden? natürlich muss alles komponentenseitig ablaufen.

[xaromz]

Hallo,

Dein Parent wird Dir nie eine WM_PAINT-Botschaft schicken, es kennt Deine Komponente ja nicht und außerdem ist diese nicht visuell. Du musst also beim Zuweisen Deines Parent dessen WindowProc ersetzen (Alte merken, durch neue ersetzen und in dieser die gemerkte am Ende aufrufen<-wichtig!). Beim Zerstören/neu zuweisen von Parent musst Du denn auch die WindowProc zurücksetzen. In Deiner WindowProc kannst Du dann die Message abfangen.

Das Ganze sieht dann so aus:

Delphi-Quellcode:

private
  FParent: TControl;
  OldWindowProc: TWndMethod;
  procedure SetParent(Control: TControl);
  procedure MyWindowProc(var Message: TMessage);
public
  destructor Destroy; override;
published
  property Parent: TControl read FParent write SetParent;
end;


destructor TMyClass.Destroy;
begin
// aufräumen
...
// Evtl. alte WindowProc wiederherstellen
  if FParent <> nil then
    FParent.WindowProc := OdWindowProc;
  inherited;
end;

procedure TMyProc.SetParent(Control: TControl);
begin
  // Alte WindowProc wiederherstellen
  if FParent <> nil then
    FParent.WindowProc := OldWindowProc;

  FParent := Control;

  // Neue WindowProc hooken
  if Control <> nil then
  begin
    OldWindowProc := FParent.WindowProc;
    FParent.WindowProc := MyWindowProc;
  end;
end;

procedure TMyClass.MyWindowProc(var Message: TMessage);
begin
  // Alte WindowProc aufrufen
  OldWindowProc(Message);

  if Message.Msg = WM_PAINT then
  begin
    // Hier auf WM_PAINT reagieren
  end;
end;

Gruß
xaromz