Classe Bouton avec callback

Version imprimable

Bonjour, je suis actuellement sur un projet SFML et j'aimerais créer un peu ma propre GUI.

J'aimerais donc créer une classe Bouton telle que :

Lorsque le bouton est détecté comme relâché, celà appelle une méthode de la classe dans laquelle il est déclaré.
Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 // interfacegraphique.h class InterfaceGraphique { public: InterfaceGraphique(); void MethodeAAppeller(); private: Bouton bouton; }; // interfacegraphique.cpp InterfaceGraphique::InterfaceGraphique() { /* J'aimerais donc, lorsque j'instancie mon bouton, stocker "l'action" qui va être exécutée lorsque le bouton aura été activé. */ this->bouton = new Bouton(MethodeAAppeller); }
J'aimerais donc savoir comment faire ça simplement.
D'avance merci pour vos réponses.
Si vous avez besoin de plus de précisions sur mon problème n'hésitez pas.

04/10/2012, 13h31
Bousk

Bonjour,

oui c'est tout à fait possible, il s'agit de foncteur ou pointeur sur fonction.

Quel code as-tu déjà à ce niveau ? Quel problème rencontres-tu ?

Alors voilà où j'en suis. J'ai déjà tenté un bon nombre de chose mais sans succès.

// Classe Bouton
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 // bouton.h class Bouton { private: // La fonction que l'on passe en paramètre TYPE function; public: Bouton(Type t); void Update(); void Click(); } // bouton.cpp Bouton::Bouton(Type t) { this->funtion = t; } Bouton::Update() { /* Ici on test si la souris à cliqué sur le bouton */ If(sourisClick) this->Click(); } Bouton::Click() { // on exécute la fonction... this->function(); }
// Classe InterfaceGraphique
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 // InterfaceGraphique.h class InterfaceGraphique { private: Bouton bouton; public: InterfaceGraphique(); void Update(); void LaFonctionAAppeller(); } // InterfaceGraphique.cpp InterfaceGraphique::InterfaceGraphique() { // J'aimerais faire un truc du genre : this->bouton = new Bouton(this->LaFonctionAAppeller); } InterfaceGraphique::Update() { this->bouton->Update(); }
J'ai déjà essayer d'utiliser std::function mais le problème était que lorsque la fonction était appelé, elle utilisait les attribut de la classe tels qu'ils étaient initialisés au début.
J’espère que j'ai été suffisamment clair.
Si il vous faut encore des précisions n'hésitez pas.

05/10/2012, 10h18
Bousk

D'où sort TYPE ? c'est la brique qu'il te manque ?

Tu peux aussi chercher du côté du DesignPattern Visitor (visiteur).

Pour pouvoir utiliser this->function(); function (de type TYPE) doit posséder un operator().

Citation:

J'ai déjà essayer d'utiliser std::function mais le problème était que lorsque la fonction était appelé, elle utilisait les attribut de la classe tels qu'ils étaient initialisés au début.

pas compris
05/10/2012, 10h27
flow10000
Oui voilà, TYPE c'est ce qu'il me manque. Je ne sais pas exactement ce que doit être cet attribut.

J'ai déjà essayer d'utiliser std::function mais le problème était que lorsque la fonction était appelé, elle utilisait les attribut de la classe tels qu'ils étaient initialisés au début, par exemple :

J'initialise un objet InterfaceGraphique avec un attribut i = 0;
LaFonctionAAppeller est telle que :
Code:

1 2 3 4 5 LaFonctionAAppeller() { cout >> i >> endl; }
Durant le déroulement du programme, je passe i à la valeur 2.
Apres cela, je clique sur le bouton, cela va donc appeler LaFonctionAAppeller et cela va m'afficher 0, comme si i n'avais jamais été modifié.

J’espère avoir été plus clair.
Je vais faire quelque recherche sur le DesignPattern Visitor pour voir.

Bon je retente à présent de passer par des pointeurs de fonction mais je suis un peu largué syntaxiquement :

// Classe Bouton

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
 
// bouton.h
typedef void(*Action)();	
 
class Bouton
{
private:
   // La fonction que l'on passe en paramètre
   Action action;
 
public:
   Bouton(Action a);
   void Update();
   void Click();
}
 
// bouton.cpp
Bouton::Bouton(Action a)
{
   this->action = a;
}
 
Bouton::Update()
{
   /* Ici on test si la souris à cliqué sur le bouton */
   If(sourisClick)
      this->Click();
}
 
Bouton::Click()
{
   // on exécute la fonction...
   this->action();
}

// Classe InterfaceGraphique

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
 
// interfacegraphique.h
class InterfaceGraphique
{
private:
   Bouton bouton;
 
public:
   InterfaceGraphique();
   void Update();
}
 
// interfacegraphique.cpp
InterfaceGraphique::InterfaceGraphique()
{
   // J'aimerais faire un truc du genre :
   // mais voilà j'ai beau essayer pas mal de truc ça fail à ce moment là..
   // this->bouton = new Bouton(this->LaFonctionAAppeller);
 
   // J'ai essayé ça sans succès :
   Action a = this->Connect;
   this->bouton = new Bouton(a);
}
 
InterfaceGraphique::Update()
{
   this->bouton->Update();
}

Je pense que cette fois je ne suis pas très loin du résultat voulu mais je bloque encore...

Le souci est que la fonction que tu veux pointer est une fonction membre. Sa signature est différente d'une fonction statique ou libre.

Tu devrais avoir un code un peu comme ça
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template< class T > struct Callback { typedef void(T::*ptrFct)(void); Callback(T* object, ptrFct method) : m_obj(object), m_method(method) {} void operator()(void) { m_obj->m_method(); } private: T* m_obj; ptrFct m_method; }; InterfaceGraphique::InterfaceGraphique() { this->bouton = new Bouton(this, InterfaceGraphique::LaFonctionAAppeller); }
J'ai des sources chez moi, je te présenterai une implémentation plus correcte ce soir si j'y pense.

05/10/2012, 12h28
flow10000

D'accord merci, je vais essayer de mon coté de m'inspirer de ton post cet après midi. Mais j'aimerais bien effectivement pouvoir jeter un petit coup d'oeuil à ton code ce soir.

Encore merci

Voilà ce que j'ai de simple pour des callback

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
class CCallback
	{
		public:
			CCallback() {}
			virtual ~CCallback() {}
			virtual void Call()=0;
	};
	class CStaticCallback : public CCallback
	{
		typedef void(*ptrfct)();
		public:
			CStaticCallback(ptrfct _pCallback)
				: m_pFct(_pCallback)
			{
 
			}
			virtual ~CStaticCallback() {}
 
			virtual void Call()
			{
				(*m_pFct)();
			}
 
		protected:
			ptrfct	m_pFct;
	};
	template< class T >
	class CEventCallback : public CCallback
	{
		typedef void(T::*ptrfct)();
		public:
			CEventCallback(T* _pObj, ptrfct _pCallback)
				: m_pObj(_pObj)
				, m_pFct(_pCallback)
			{
 
			}
			virtual ~CEventCallback() {}
 
			virtual void Call()
			{
				(m_pObj->*m_pFct)();
			}
 
		protected:
			T*		m_pObj;
			ptrfct	m_pFct;
	};