FAQ Qt

FAQ QtConsultez toutes les FAQ

Nombre d'auteurs : 26, nombre de questions : 298, dernière mise à jour : 15 juin 2021

Sommaire→Intégration avec d'autres bibliothèques→Généralistes→boost.signals

Comment combiner les signaux de Boost (boost.signals) aux signaux/slots de Qt ?
Comment utiliser un boost.signal connecté à un signal Qt ?
Comment utiliser un boost.signal connecté à un slot Qt ?
Comment utiliser un signal Qt connecté à une fonction standard par boost.signal ?

Version hors-ligne

Comment combiner les signaux de Boost (boost.signals) aux signaux/slots de Qt ?

Il est intéressant de savoir faire ceci dans la mesure où vous désirez utiliser des classes écrites en C++ pur avec les mécanismes Qt. Par exemple, une couche métier utilisant le mécanisme de boost.signals comme implémentation du pattern observateur, que vous désirez connecter à la couche IHM écrite à l'aide de Qt.

Quelques considérations avant d'illustrer ceci :

si vous intégrez Qt et boost.signals dans un même fichier (requis pour permettre l'appel d'une fonction standard depuis un signal Qt), il est impératif d'inclure les en-têtes boost en premier (sinon, vous obtiendrez des erreurs de compilation dues à Qt utilisant un #define sur signals) ;
un prérequis à l'utilisation de sender() dans un slot pour connaître l'origine de l'appel est la vérification de la validité du QObject* retourné. On préfèrera généralement éviter d'utiliser ce paramètre.

Deux raisons à ce dernier point :

un slot peut être appelé comme une fonction normale (et, par conséquent, il n'y a pas d'objet appelant généré par le système de métaobjets Qt) ;
un slot est appelé comme une fonction normale lors d'un appel par boost.signals (voir point précédent).

Les scénarios suivants sont envisagés :

utilisation d'un boost.signal connecté à un slot Qt ;
utilisation d'un boost.signal connecté à un signal Qt ;
utilisation d'un signal Qt connecté à une (des) fonction(s) C++ standard par le biais de boost.signal.

Les aspects les plus intéressants de l'implémentation sont illustrés par des portions de code dans les réponses aux questions suivantes.

Créé le 30 octobre 2009 par Denys Bulant

Lien : Comment utiliser un boost.signal connecté à un slot Qt ?
Lien : Comment utiliser un boost.signal connecté à un signal Qt ?
Lien : Comment utiliser un signal Qt connecté à une fonction standard par boost.signal ?

Comment utiliser un boost.signal connecté à un signal Qt ?

Un signal, du point de vue de Qt, n'est qu'une méthode standard, le mot clé signals étant redéfini par Qt comme protected. Il est donc nécessaire de fournir une méthode pour déclencher ce signal avec le(s) paramètre(s) voulu(s). Il y a deux approches possibles : la première consiste à ajouter une méthode à votre classe Qt, la seconde à utiliser une classe de pont.

Bien que plus verbeuse, la seconde méthode permet de découpler réellement la couche utilisant Qt de la couche sans Qt en "intercalant" une couche servant d'adaptateur.

Ici, ce sera la première méthode qui sera illustrée.

Cacher/Afficher le codeSélectionnez

class QtClass : public QObject
{
Q_OBJECT

public:
    QtClass()
    {
        connect(this, SIGNAL(qtSignal(float)), this, SLOT(qtSlot(float)));
    }

    // OBLIGATOIRE si on veut connecter un signal boost à un signal Qt : les signaux sont **protégés**
    void triggerQtSignalEmission(float x)
    {
        emit qtSignal(x);
    }

signals:
    void qtSignal(float);
};

class NonQtClass
{
public:
    void boostSignalToQtSignal(QtClass *qc)
    {
        boost::signal<void (float)> sig;
        sig.connect(boost::bind(&QtClass::triggerQtSignalEmission, qc, _1));
        sig(42.0f);
    }
};

Sortie obtenue

Sélectionnez

D'une connexion interne :
Dans QtClass::qtSlot(), x=42

Mis à jour le 7 mai 2012 par Denys Bulant

Lien : Comment combiner les signaux de Boost (boost.signals) aux signaux/slots de Qt ?
Lien : Comment utiliser un boost.signal connecté à un slot Qt ?
Lien : Comment utiliser un boost.signal connecté à un signal Qt ?

Comment utiliser un boost.signal connecté à un slot Qt ?

Un slot, du point de vue de Qt, est en réalité une fonction standard à laquelle peuvent être associées les informations de l'objet appelant, si ledit slot est appelé depuis un signal Qt.

Cacher/Afficher le codeSélectionnez

class QtClass : public QObject
{
Q_OBJECT
public slots:    void qtSlot(float x)
    {
        QObject *s = sender();
        if(s == this)
            std::cout << "D'une connexion interne :" << std::endl;
        else if(!s)
            std::cout << "Envoyeur inconnu :" << std::endl;
        std::cout << "Dans QtClass::qtSlot(), x=" << x << std::endl;
    }
};

class NonQtClass
{
public:
    void boostSignalToQtSlot(QtClass *qc)
    {
        boost::signal<void (float)> sig;
        sig.connect(boost::bind(&QtClass::qtSlot, qc, _1));
        sig(3.14f);
    }
};

Sortie obtenue

Sélectionnez

Envoyeur inconnu :
Dans QtClass::qtSlot(), x=3.14

Mis à jour le 7 mai 2012 par Denys Bulant

Lien : Comment combiner les signaux de Boost (boost.signals) aux signaux/slots de Qt ?
Lien : Comment utiliser un boost.signal connecté à un signal Qt ?
Lien : Comment utiliser un signal Qt connecté à une fonction standard par boost.signal ?

Comment utiliser un signal Qt connecté à une fonction standard par boost.signal ?

Ce cas de figure est plus complexe que les précédents. En effet, nous savons :

qu'un signal Qt est une méthode protégée ;
que le corps d'un signal Qt va associer les informations sur l'objet émetteur (dans le but de permettre l'utilisation de la méthode sender() dans le slot) ;
que nous ne pouvons passer de fonctions standard à un signal Qt.

Nous allons donc mettre en place ici une méthode impliquant la création d'une classe servant d'adaptateur entre les deux paradigmes (signaux Qt / boost.signals).

Cacher/Afficher le codeSélectionnez

class QtClass : public QObject
{
Q_OBJECT

public:
    // OBLIGATOIRE si on veut connecter un signal boost à un signal Qt: les signaux sont **protégés**
    void triggerQtSignalEmission(float x)
    {
        emit qtSignal(x);
    }

signals:
    void qtSignal(float);
};

class QtSignalToStandardCPPBridge : public QObject
{
Q_OBJECT

public:
    QtSignalToStandardCPPBridge(QtClass *qc)
    {
        connect(qc, SIGNAL(qtSignal(float)), this, SLOT(onQtSignalEmitted(float)));
    }

    template<typename Signature>
    void addStandardSlot(Signature fun)
    {
        sig.connect(fun);
    }

private slots:
    void onQtSignalEmitted(float x)
    {
        sig(x);
    }

private:
    boost::signal<void (float)>sig;
};

class NonQtClass
{
public:
    // fonction normale que l'on appellera depuis un signal Qt en passant par un pont
    void normalFunction(float x)
    {
        std::cout << "Dans NonQtClass::normalFunction(), x=" << x << std::endl;
    }

    // Et une autre pour le fun
    void displaySquareRoot(float x)
    {
        std::cout << "Dans NonQtClass::displaySquareRoot(), sqrt(x)=" << std::sqrt(x) << std::endl;
    }

public:
    void QtSignalToStandardFunction(QtClass *qc)
    {
        QtSignalToStandardCPPBridge adapter(qc);
        adapter.addStandardSlot(boost::bind(&NonQtClass::normalFunction, this, _1));
        adapter.addStandardSlot(boost::bind(&NonQtClass::displaySquareRoot, this, _1));
        // On déclenche ici manuellement l'émission du signal Qt
        qc->triggerQtSignalEmission(121.0f);
    }
};

Sortie obtenue

Sélectionnez

Dans NonQtClass::normalFunction(), x=121
Dans NonQtClass::displaySquareRoot(), sqrt(x)=11

Mis à jour le 7 mai 2012 par Denys Bulant

Version hors-ligne

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006 - 2017 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.