Discussion :

[b Oo]

Bonjour,
je réalise une application avec la SDL, et j'ai crée des boutons. Je voudrais que lorsqu'un bouton est pressé cela appelle la bonne fonction.

La solution : Signals and Slots de Qt me parait intéressante et j'aimerais pouvoir l'implémenter.

Pour cela, je pensais faire une classe Connecteur et une fonction connect qui prend l'objet emetteur, la méthode qui envoie le signal, l'objet recepteur, et la méthode qui doit recevoir le signal.

Idée pour la classe Connecteur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
template <class Emetteur, class Recepteur>
class Connecteur
{
    Emetteur & emetteur;
    Connecteur & connecteur;
    // Et la problème je ne peux pas déclarer mes pointeurs sur des méthodes
    // car je peux avoir void, int, ...
};

De plus admettons que je puisse faire la déclaration de mes méthodes (c'est peux etre possible en s'inspirant de mem_fun), je voudrais un conteneur de pointeurs sur mes objets, et de pointeurs sur mes méthodes pour pouvoir y accéder de cette maniere :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
// admettons que ce code marche
Bouton bouton;
Receveur receveur;
connect(&bouton, &bouton::onCLic, &receveur, &Receveur::methode);

onClic a le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void Bouton::onClic()
{
    Connecteur::send(this, &Bouton::onClic);
}

et send :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
void Connecteur::send(Emetteur & emetteur, PtrEMethode methode) // PtrEMethode est un typedef pour un pointeur de methode de emetteur
{
    Recepteur * objet = connecteurs[emetteur][methode].first;
    PtrRMethode * methodeR =  connecteurs[emetteur][methode].second;
    objet->(*methodeR)();
}

Avec ce code je dois forcement avoir une methode qui n'a pas de parametres donc c'est très limité, mais bon le problème est que cette idée d'implémentation ne me parait pas réalisable.

J'aimerais avoir votre avis, et savoir comment vous feriez pour implémenter ceci, ou s'il y a une meilleur méthode que celle utilisée par Qt faite le moi savoir.

D'avance merci.

[Mat007]

Salut,

Tu as jeté un oeil sur boost.signals ?

MAT.

[b Oo]

Je vais me pencher de ce pas sur le lien que tu viens de me donner Mat007.

Merci !

[loufoque]

Je n'ai jamais compris comment on pouvait même avoir l'idée d'un truc comme le système de Qt.

C'est simple, quand un événement se produit tu veux appeler un foncteur. Alors quand un événement se produit, appelle ce foncteur.
Voilà, c'est tout.

T'as juste besoin d'une manière unifiée de pouvoir stocker les différents types de foncteurs, et c'est boost::function.

[b Oo]

Bonjour loufoque,
amdettons que j'ai un bouton, je veux lui connecter une fonction, une méthode ou plusieurs, tu ferais comment ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Bouton monBouton;
monBouton.connect(/* un foncteur */);
monBouton.connect(/* un autre foncteur */);

Admettons que le premier foncteur est crée a partir d'un void toto() et le deuxieme d'un int tata(int);
Comment je declare le signal dans mon bouton ?

De plus admettons que j'ai deux methodes auxquelles je dois connecter des foncteurs differents, comme je peux faire ?
Avec un connect qui prend en parametre le signal que auquel je veux connecter ?

Ce que je veux faire est-il réalisable avec boost ?

Merci.

[Laurent Gomila]

Un exemple de ce que l'on peut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class Bouton
{
public :
 
    void OnClick(boost::function<void ()> F)
    {
        myOnClick = F;
    }
 
    void OnMouseMove(boost::function<void (int, int)> F)
    {
        myOnMouseMove = F;
    }
 
private :
 
    void Update()
    {
        if (... detection du click souris ...)
            myOnClick();
 
        if (... detection du mouvement souris en (X, Y) ...)
            myOnMouseMove(X, Y);
    }
 
    boost::function<void ()> myOnClick;
    boost::function<void (int, int)> myOnMouseMove;
};
 
void OnMouseMove(int X, int Y)
{
    std::cout << "Déplacement de la souris sur le bouton en " << X << ", " << Y << std::endl;
}
 
struct ClickHandler
{
    void OnClick()
    {
        std::cout << "Click sur le bouton" << std::endl;
    }
};
ClickHandler Click;
 
Bouton monBouton;
monBouton.OnClick(boost::bind(&ClickHandler::OnClick, Click));
monBouton.OnMouseMove(boost::bind(&OnMouseMove));

[Code sorti à la volée sans vérification]

[JolyLoic]

C'est simple, quand un évènement se produit tu veux appeler un foncteur. Alors quand un évènement se produit, appelle ce foncteur.
Voilà, c'est tout.

T'as juste besoin d'une manière unifiée de pouvoir stocker les différents types de foncteurs, et c'est boost::function.

En gros, boost::signal, c'est ce que tu dis avec quelques détails supplémentaires, de tête :
- La possibilité de gérer n foncteurs pour un signal (y compris en gérant la combinaison des valeurs de retour)
- Une sorte de gestion automatique des durées de vie, qui efface les objets de connections quand un objet possédant un signal où un slot est détruit.

[b Oo]

Je m'explique, je veux savoir si c'est possible de faire ceci avec une seule classe plutôt que 2.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
class Bouton1
{
    public:
      void onEvent(Event & event)
      {
         if(/* clic */)
           onClic();
      }
      void connect(boost::function<void ()>f)
      {
         onClic = f;
      }
 
    private:
      boost::function<void ()> onClic;
};
 
class Bouton2
{
    public:
      void onEvent(Event & event)
      {
         if(/* clic */)
           onClic(event.x, event.y);
      }
      void connect(boost::function<void (int, int)>f)
      {
         onClic = f;
      }
 
    private:
      boost::function<void (int, int)> onClic;
};
 
void affiche(int x, int y)
{
    std::cout << "Clic a la position : " << x << ',' << y << ".\n";
}
 
/* J'ai une instance app de Application qui a une methode quit() */
Application app;
Bouton1 bouton1;
bouton1.connect(boost::bind(&Application::quit(), app);
 
Bouton2 bouton2;
bouton2.connect(boost::bind(&affiche);

Si le paramètre est connu au moment où tu connectes le slot, tu peux le spécifier à boost::bind.

Ici, c'est comme si je faisais un bind1st ou bind2nd ?