Ereignissse von dynamischen Controls innerhalb einer Klasse

AndreasW

//Header- Datei

#ifndef TBILDOBJEKT_H
#define TBILDOBJEKT_H
//---------------------------------------------------------------------------

#include <vcl>
#include <jpeg.hpp>
class TGrafObj
{
   private:
     int        F_Links, F_Oben;
     int        F_Breite, F_Hoehe;
     TImage*    F_Bild;
     TWndMethod OldImageProc; 
     void setLinks( const int &i_Links)            ;  // warum hier mit Referenzen arbeiten ? 
     void setOben ( const int &i_Oben)             ;
     void setBreite( const int &i_Breite)          ;
     void setHoehe ( const int &i_Hoehe)           ;
  protected: // [Edit] Eingefügt, da virtuelle Methoden nur ab protected was nutzen [/Edit]
     DYNAMIC void __fastcall ImageProc(Messages::TMessage &Message);

   public:
     // Da du Standardwerte setzt, default setzen:
     __property AnsiString ObjName    = {read = getObjName,  write = setObjName };
     __property int        Links      = {read = F_Links,     write = setLinks   ,default=0 };
     __property int        Oben       = {read = F_Oben,      write = setOben  ,default=0   };
     __property int        Breite     = {read = F_Breite,    write = setBreite ,default=100  };
     __property int        Hoehe      = {read = F_Hoehe,     write = setHoehe , default=100   };

     TGrafObj( TWinControl *Owner );

     ~TGrafObj();

};
#endif

//CPP - Datei

//----------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "TBildObjekt.h"
//----------------------------------------------------------

TGrafObj::TGrafObj( TWinControl *Owner )
    :F_Links(0),F_Oben(0),FBreite(100),F_Hoehe(100)
{
 F_Bild = new TImage(Owner);
 F_Bild->Parent = Owner;
 F_Bild->SetBounds(0,0,100,100);
 OldImageProc=F_Bild->WindowProc;
 F_Bild->WindowProc=ImageProc;
}
//----------------------------------------------------------

TGrafObj:: ~TGrafObj()
{
 F_Bild->WindowProc=OldImageProc;
 delete F_Bild;
}
//----------------------------------------------------------
void __fastcall TGrafObj::ImageProc(Messages::TMessage &Message)
{

if(OldImageProc)OldImageProc(Message);

//mach was
}

[ Dieser Beitrag wurde am 13.01.2003 um 08:03 Uhr von AndreasW editiert. ]

spool

Thx, funktioniert alles wunderbar, bis auf die default Werte.
Compilermeldung: für default ist ein Klassentyp im VCL-Stil erforderlich

Was fehlt denn hier noch ?

P.S. Die Referenzen hab ich genommen, damit man ( lt. meinem schlauen Buch, da war ne Vorlage drin) nicht unbeabsichtigt die Werte ändern kann. Ich versteh's zwar auch nicht ganz, aber ich dachte mir, wenn einer ein Buch schreibt, der hat wohl Ahnung ;-)).

AndreasW

Original erstellt von spool:
**:) Thx, funktioniert alles wunderbar, bis auf die default Werte.
Compilermeldung: für default ist ein Klassentyp im VCL-Stil erforderlich

Was fehlt denn hier noch ?
**

Sorry, du hast nicht von einer VCL- Klasse abgeleitet. Nimm einfach die default- Sachen raus. ( War mein Fehler;Hätte ich sehen müssen).

Diese Default- Werte sind nämlich nur für Klassen geeignet, die von einer VCL- Klasse abgeleitet wurden.
Das ist aber nicht erforderlich.

Original erstellt von spool:
P.S. Die Referenzen hab ich genommen, damit man ( lt. meinem schlauen Buch, da war ne Vorlage drin) nicht unbeabsichtigt die Werte ändern kann. Ich versteh's zwar auch nicht ganz, aber ich dachte mir, wenn einer ein Buch schreibt, der hat wohl Ahnung ;-)).

Das hast du falsch verstanden. Wenn man eine Funktion schreibt, die als Parameter Referenzen erwarten, so kann man inerhalb dieser Funktion diese Parameter ändern.

Beispiel:

void test( int & AValue)
{
AValue=5;
} 

int main()
{
int T=3;
test(T);
cout<<T; // Es wird "5" ausgegeben
return 0;
}

Um sowas zu verhindern schreibt man ein "const" davor. Konstante Parameter können nicht verändert werden. Du würdest bereits beim Compilieren eine Fehlermeldung bekommen.
Beispiel:

void test( const int & AValue)
{
AValue=5;
} 

int main()
{
int T=3;
test(T);
cout<<T; // Es wird "5" ausgegeben
return 0;
}

so wird eine versehentliche Veränderung verhindert.

spool

Das DYNAMIC mag der Compiler auch im protected Bereich nicht.
DYNAMIC ist hier nicht erlaubt (oder so ähnlich).

zu Referenzen:
Damit hab ichs noch nicht so (Umsteigerkrankheit vielleicht). Const ist mir klar, das gabs auch bei VB schon.

AndreasW

ja,

DYNAMIC ist ungefähr das selbe wie "virtual". Du kannst also DYNAMIC durch "virtual" ersetzen.
Du brauchst die Methde aber nur als virtual zu deklarieren, wenn du eine Klasse von dieser ableiten und die Methode überschreiben möchtest. Ansonsten kannst du es auch einfach weglassen.

WebFritzi

DYNAMIC = virtual

Aber ich frage mich, warum du nicht gleich eine neue Komponente schreibst. Du könntest sicher die eine oder andere Eigenschaft der einen oder anderen VCL-Klasse gebrauchen. Und warum ist *Owner TWinControl und nicht TComponent? Naja, deine Sache.

WebFritzi

Huups, da war ja einer viel schneller.

AndreasW

jep

Und warum ist *Owner TWinControl und nicht TComponent?

wahrscheinlich möchte er sichergehen, das ein fensterorientiertes Objekt als Parameter übergeben wird

[ Dieser Beitrag wurde am 14.01.2003 um 23:35 Uhr von AndreasW editiert. ]

WebFritzi

Na gut, wegen des Parent des Images. Aber dann sollte man den Parameter nicht Owner nennen, weil das was anderes ist in der VCL.

spool

Ich bin aber an den Owner aus VB gewöhnt und alte Gewohnheiten hält man halt bei.