appeler une fonction dans une classe générée

Version imprimable

01/01/2009, 22h41
jeanmichmuch66

appeler une fonction dans une classe générée

Bonjour,

J'ai un programme qui génére des classes dérivées d'un TGroupbox dans laquelle j'ai une fonction.
Je souhaiterais par un clic dans ma fiche principale TForm1 appeler ma fonction.

Je sais appeler une fonction de ma fiche principale de ma classe avec ce code

Code:

Form1->mafonction;

mais dans l'autre sens je ne connait pas le name de ma classe puisquelle est générée par ma fiche.

Jespère avoir été suffisament clair, merci d'avance.

Et BONNE ANNEE 2009.

J-Mi.
02/01/2009, 13h30
sat83
Il faut à un moment que tu créer une instance de ta classe (un objet). Ensuite tu utilise cet objet pour appeler ta fonction :
Code:

1 2 3 4 TMaClasse *monObjet = new TMaClasse() ; monObjet->MaFonction() ; //[...] delete monObjet ; //ne pas oublier de libérer l'objet
Je ne suis pas sûr d'avoir répondu a ta question, car je ne suis pas sûr de l'avoir comprise!
02/01/2009, 23h03
jeanmichmuch66

Merci sat83,c'est bien ça, mais le soucis que j'ai c'est que je génère plusieures Classes et que je ne sais pas comment pointer sur la bonne pour activer la fonction lorsque je clique dessus.
Ce qu'il me faudrais en fait c'est de connaitre le parent de l'objet (la classe) sur lequel je clic, je pense que je pourrait arriver a ce que je veux avec ça.

Merci.
02/01/2009, 23h39
Sunchaser
Bonsoir,

Mais comme a priori la fonction doit être appellée au moment d'un click sur un des objets (quelle que soit la classe, et si j'ai bien compris une fonction par classe), n'est il pas possible de déclarer l'execution cette fonction directement dans l'évènement OnClick() de la class ?
QQchose qui donnerait un truc comme:
Code:

1 2 3 4 5 void __fastcall MaClass::OnClick(TObject* Sender) { MaClass->LaFonction(); }
Afin que chaque LaFonction() soit appellée "de base" dans l'évènement on click() de chaque class.

Bon, je n'ai peut etre pas forcement saisi le problème, donc désolé si hors sujet.

@+
;)

Pour être plus précis:

sur ma fiche "Form1" je génére n "ClassA" contenant n "ClassB" et dans cette ClasseB j'ai ma fonction
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void __fastcall ClasseA::FClassBClick(TObject *Sender) { if (VK_LBUTTON==true) { ClassBClick= dynamic_cast <ClasseB *> (Sender); if (ClassBClick != NULL) { ClassBClick->Nb=Form1->Mem->Nb ; ClassBClick->Type=Form1->Mem->Type; ClassBClick->Format=Form1->Mem->Format; ClassBClick->Picture=Form1->Mem->Picture; toto=toto.Delete(1,5); if (Form1->Mem->Type!=NULL) { ((TLabel*)(this->Nom->Items[StrToInt(toto)]))->Visible=true; } }
que j'appelle par le PopupMenu de ClassB

Code:

((ClasseB*)(this->C->Last()))->OnClick=FCarteClick;

et cette fonction je souhaiterais l'appeler sous Form1 en cliquant sur un item du PopupMenu des ClasseB générées.

infos :
ClassA est dérivée d'un TGroupbox
ClassB est dérivé d'un TImage
Mem est un ClassB
Nom est un TList
C est un TList
je souhaiterais aussi par la suite pointer le TLabel "enfant" de ClassB afin de le rendre invisible.
Jespère avoir donné suffisament d'infos.
Merci

03/01/2009, 12h31
Sunchaser

Bonjour,

Les classeB générée sont "stockée" dans un TList ?
Est ce que l'on peut imaginer que le popupmenu est ordonné de la même manière que la TList, afin que si tu cliques sur le deuxième item du popupmenu, tu puisses donc pointer vers le deuxième objet "contenu" dans la TList.
Tu vas donc réaccéder aux propriétés et méthodes du classeB en question.

@+
;)

Re,

Un bout de code, histoire d'illustrer ce a quoi je pensais (même si finalement ce n'est peut être pas tout a fait la même situation):
.h:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//une classe déclarée en amont de la fiche
class TMCombo : public TCustomComboBox
{

private:
public:		// Déclarations de l'utilisateur
	__fastcall TMCombo(TComponent* Owner);
	void __fastcall SayWha(TObject *Sender);
};

//dans la TForm
private:
void __fastcall SayIt(TObject *Sender);

	TMCombo *MyCombo;
	TList *cList;

.cpp:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
//pour la classe TMCombo
__fastcall TMCombo::TMCombo(TComponent* Owner) : TCustomComboBox(Owner)
{
}
void __fastcall TMCombo::SayWha(TObject *Sender)
{
   String S = ((TMCombo*)Sender)->Name ;
ShowMessage(S);
}
 
//dans la TForm:
void __fastcall TForm2::ToolButton2Click(TObject *Sender)
{
cList = new TList();
for (int i = 0;i < 2 ;i++ ) {
	MyCombo = new TMCombo(this);
	MyCombo->Parent = this;
	MyCombo->Name = "MyCombo" + IntToStr(i+1);
	MyCombo->Top = 10 * (i+1);
	MyCombo->Left = 10 * (i+1);
cList->Add(MyCombo);
TMenuItem *pItem = new TMenuItem(Form2->MainMenu1);
pItem->Caption = "MyCombo No " + IntToStr(i+1);
pItem->Tag = i;
pItem->OnClick = SayIt;
Form2->MainMenu1->Items->Add(pItem);
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::SayIt(TObject *Sender)
{
	MyCombo = (TMCombo *)cList->Items[ ((TMenuItem*)Sender)->Tag ];
	MyCombo->SayWha(MyCombo);
}

Pour le coup, j'utilise la propriété "Tag" du MenuItem.

En espérant t'aider,
@+
;)

04/01/2009, 01h25
jeanmichmuch66

Il faut que je regarde en profondeur et je te dis ce qu'il en est mais pour l'instant je n'y suis pas arrivé.

Merci
04/01/2009, 13h39
henderson

Salut !

Et pourquoi ne pas développer une classe supplémentaire pour associer les objets qui doivent l'être ?
Ce serait plus simple... en dérivant de TComponent ! Oui ... Non ?
Je pense que ça pourrait même permettre de faire abstraction des TList (pour ce que je pense avoir compris) !

En fait, ca reviendrait à se servir de l'Owner de chaque objet dans l'association et non plus du Tag, avec une plus grande flexibilité (même si ce programme ne devait en utiliser, in fine, qu'une petite part) !

En ce qui concerne les événementielles (OnClick etc..) l'objet cible est donné par le Sender.

Par contre, ce serait bien d'avoir une vision complète de ce que l'on souhaite faire : qui est associé à quoi et qui fait quoi ?

A plus !
04/01/2009, 22h58
jeanmichmuch66
Effectivement je peux pointer le "classB" grace a mon TList, mais mon problème est que je n'arrive pas a obtenir le "ClassB" (Sender) qui est a l'origine de mon PopupMenu.
Alors j'ai fait ça:

Code:

this->PMenuChoixClassB->OnPopup= FClic;

puis
Code:

1 2 3 4 5 void __fastcall TForm1::FClic(TObject *Sender) { M= (ClassB*)(TPopupMenu*)Sender; int i= M->NumA; }
M étant donc un classB
et NumA étant un int que j'ai intégré a mon ClassB donnant le ClassA auquel il appartient.
Mais malheureusement ça ne marche pas, j'obtient quelque chose mais ça n'a rien a voir avec ce que j'attends.
Si quelqu'un voit où est l'erreur ... je suis preneur.
Merci
06/01/2009, 22h37
jeanmichmuch66

Personne n'a d'idée pour mon problème ?
Pointer sur le Sender du PopupMenu, si quelqu'un a vu une erreur dans mon code, merci.
06/01/2009, 22h52
Sunchaser
Bonsoir,

Je ne pense pas que:
Code:

1 2 M= (ClassB*)(TPopupMenu*)Sender;
puisse fonctionner.

Dans mon humble exemple, j'imaginais utiliser le "tag" afin de pouvoir pointer vers un des objets de la TList a un index particulier.
De ce fait, tout dépends de quand et comment les "classes" sont crées et dans le même temps comment les items du popupmenu sont crées.
L'idéal aurait été, si tu passes par cette idée, de stocker dans la propriété "tag" l'index a laquelle se situe l'objet vers lequel pointer dans la TList.

Voili,
En espérant t'aider,
@+
;)
06/01/2009, 23h01
jeanmichmuch66

Oui, merci j'avais bien compris cette partie là et j'ai intégré dans ma classB dequoi la pointer mais pour pouvoir le pointer j'ai besoin de savoir lequel de ces ClassB est a l'origine du PopupMenu ciblé, afin que j'en extrait sa position.
Enfin je pense, si j'ai bien compris ta solution, qui d'ailleur était mon objectif.

Code:

int i= M->NumA;

étant l'équivalent du Tag je pense.
Mais si je ne me trompe pas tu te sert du tag pour pointer par rapport a ton item de PopupMenu.
Alors que moi l'item menu j'ai déjà géré ça fonction mais je veux l'appliquer a la ClassB appelant le PopupMenu.
Je ne sais pas si j'ai été suffisament clair.
06/01/2009, 23h49
jeanmichmuch66

pour entrer plus dans le détail:
les n ClassA étant des dérivés de Groupbox pouvant contenir n ClassB "vides" dérivés de TImage.
Mon PopupMenu est appelé en cliquant sur les ClassB et contient des items pointant sur des ClassB "préremplis".
Et le but est donc de remplir les ClassB pointés "vides" par les infos contenus dans les ClassB "remplis" pointés par les items .

Je peux donc avoir que 4,5 ou plus ClassB "remplis" (appelés par les items) et 10 ou 50 ClassB "vides" répartis dans n Class A.
les ClassA et ClassB étants tous listés (TList).

Est ce plus clair ?

Salut !

Voici un exemple qui n'utilise qu'un seul groupbox source et un seul groupbox de destination.
Sur la fiche (Form1) on suppose l'existance d'un TImage (Empty1) qui est rendu invisble pour représenter une image vide (chez moi un carré avec un point d'interrogation), ainsi qu'un TPopupMenu (PopupMenu1).
Dans le dossier du projet/exécutable on suppose également l'existance de quelques images (chez moi des bitmaps)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
class jGroupBox : public TGroupBox
{
public :
    __fastcall jGroupBox(TWinControl *AOwner, int NbImages, bool Source);
    __fastcall ~jGroupBox();
};
 
class jImage : public TImage
{
public :
    __fastcall jImage(TWinControl *AOwner, int N, TPoint *Pos, bool Source);
    __fastcall ~jImage();
};
 
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
    TPopupMenu *PopupMenu1;
    TImage *Empty1;
private:	// Déclarations de l'utilisateur
public:		// Déclarations de l'utilisateur
    __fastcall TForm1(TComponent* Owner);
 
    void __fastcall SelectSource(TObject *Sender);
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
AnsiString Filepath;
AnsiString Images[4];
 
 
//------------ Méthodes de jGroupBox
__fastcall jGroupBox::jGroupBox(TWinControl *AOwner, int NbImages, bool Source)
    : TGroupBox(AOwner)
{
Parent = AOwner;
TPoint Pos = Point(10,10);
for(int j = 0; j < NbImages; j++)
    {
    new jImage(this, j, &Pos, Source);
    Pos.y = Pos.y + 30;
    }
}
__fastcall jGroupBox::~jGroupBox()
{
}
 
//------------ Méthodes de jImage
__fastcall jImage::jImage(TWinControl *AOwner, int N, TPoint *Pos, bool Source)
    : TImage(AOwner)
{
Parent = AOwner;
SetBounds(Pos->x, Pos->y, 26, 26);
if(Source)
    {
    Picture->LoadFromFile(Images[N]);
    TMenuItem *M = new TMenuItem(this);
    M->Caption = "Image " + IntToStr(N+1);
    M->Tag = (int)this;
    M->OnClick = Form1->SelectSource;
    Form1->PopupMenu1->Items->Add(M);
    }
else
    {
    Picture->Assign(Form1->Empty1->Picture);
    PopupMenu = Form1->PopupMenu1;
    }
}
 
__fastcall jImage::~jImage()
{
}
 
 
//------------ Méthodes de TForm1
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
Filepath = ExtractFilePath(Application->ExeName);
Images[0] = Filepath + "Image1.BMP";
Images[1] = Filepath + "Image2.BMP";
Images[2] = Filepath + "Image3.BMP";
Images[3] = Filepath + "Image4.BMP";
 
jGroupBox *G1 = new jGroupBox(this, 4, true);
G1->SetBounds(10,10,80,200);
 
jGroupBox *G2 = new jGroupBox(this, 6, false);
G2->SetBounds(100,10,170, 200);
}
 
 
void __fastcall TForm1::SelectSource(TObject *Sender)
{
//Le sender est un menuitem du popupmenu
TMenuItem* M = (TMenuItem*)Sender;
 
//L'adresse de l'objet source est dans le Tag du menuitem :
jImage *Srce = (jImage*)M->Tag;
 
//L'objet de destination est l'objet qui est à l'origine du popup :
jImage *Dest = (jImage*)PopupMenu1->PopupComponent;
 
//Sans doute qu'il ne reste plus qu'à faire :
Dest->Picture->Assign(Srce->Picture);
}

Si maintenant le contexte devait évoluer en plusieurs GroupBox Sources, dans ce cas il fauudrait modifier légèrement.
Chaque GroupBox Source crée alors un MenuItem qu'il ajoute à PopupMenu1 et que l'on passe aux Images (dans leur constructeur qu'il faudra donc modifier en conséquence) pour qu'elles y attachent le menuitem auquel elles sont associéés pour obtenir une organisation sous form de menus (GroupBox) et de sous menus (Images).

A ce stade, on n'a pas besoin de TList.

A plus !

Me revoila,
Pour ce qui est de mon appel de fonction sur le PopupMenu d'une autre Classe j'ai finalement modifié ma Classe pour lui ajouter la fonction et gerer les clic droit et gauche différement comme suit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 void __fastcall Class_Rack::FClassBClick(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { if (Button==mbRight) { M = dynamic_cast <ClassB *> (Sender);// qui ce fera en même temps que le PopupMenu. } if (Button==mbLeft) { ClassBClic = dynamic_cast <ClassB*> (Sender); if (ClassBClic != NULL) { //Opérations } } }
Voilà
Un grand merci a ceux qui on contribué a ma recherche.
@ bientôt
J-Mi.