usando señales boost en lugar de qt

Question

Esto es una posibilidad remota pero, habiendo encontrado una restricción en forma de señales de qt, las ranuras no pueden ser templadas, solo estoy pensando en reemplazarlas con señales de refuerzo, ¿eso sería? ser una opción viable?

Answer 1

No está obligado a utilizar las señales y ranuras de qt. De Using Qt with 3rd Party Signals and Slots:

Es posible utilizar Qt con un mecanismo de señal/ranura de un tercero. Usted puede incluso usar ambos mecanismos en el mismo proyecto. Simplemente agregue la siguiente línea a su archivo de proyecto qmake (.pro).

CONFIG += no_keywords 

Se dice Qt no definir la moc señales de palabras clave, ranuras, y emiten, porque estos nombres serán utilizados por una biblioteca tercera parte, por ejemplo, Aumentar. luego continuar utilizando señales y ranuras Qt con la bandera no_keywords, Sólo tiene que sustituir todos los usos de las palabras clave moc Qt en sus fuentes con los correspondientes macros Q_SIGNALS Qt (o Q_SIGNAL), Q_SLOTS (o Q_SLOT), y Q_EMIT.

Hay un complete explanation de cómo conectar las señales de impulso a las señales de qt.

---

me encontré con este adaptador en algún lugar de la red, pero ni idea de dónde:

#ifndef _QT_2_FUNC_3_H_ 
#define _QT_2_FUNC_3_H_ 

#include <iostream> 

#include <boost/function.hpp> 
#include <boost/type_traits.hpp> 

#include <QObject> 

#include <libQtSignalAdapters/QtConnDefault.h> 

using namespace boost; 

namespace QtSignalAdapters 
{ 

/** 
* \cond 
*/ 
template<typename SIGNATURE> 
class Qt2FuncSlot3 
{ 
public: 
    typedef function<SIGNATURE> FuncType; 
    typedef typename function_traits<SIGNATURE>::arg1_type ParmType1; 
    typedef typename function_traits<SIGNATURE>::arg2_type ParmType2; 
    typedef typename function_traits<SIGNATURE>::arg3_type ParmType3; 

    Qt2FuncSlot3(const FuncType& func) : 
     func_(func) 
    { 
    } 

    void call(QObject* sender, void **arguments) 
    { 
     ParmType1* a1 = reinterpret_cast<ParmType1*>(arguments[1]); 
     ParmType2* a2 = reinterpret_cast<ParmType2*>(arguments[2]); 
     ParmType3* a3 = reinterpret_cast<ParmType3*>(arguments[3]); 
     if (func_) 
      func_(*a1,*a2, *a3); 
    } 

private: 
    FuncType func_; 
}; 
/** 
* \endcond 
*/ 

template<typename SIGNATURE> 
class Qt2Func3 : public QObject, public QtConnDefault 
{ 
public: 
    typedef function<SIGNATURE> FuncType; 
    typedef typename function_traits<SIGNATURE>::arg1_type ParmType; 

    Qt2Func3(QObject* qobject, int signalIdx, const FuncType& func, 
      bool initiallyConnected=true) : 
     QObject(qobject), 
     QtConnDefault(qobject, signalIdx), 
     func_(func) 
    { 
     // 
     // Get the next usable slot ID on this... 
     // 
     slotIdx_ = metaObject()->methodCount(); 

     // 
     // Create a slot to handle invoking the boost::function object. 
     // 
     slot_ = new Qt2FuncSlot3<SIGNATURE>(func); 

     if (initiallyConnected) 
      connect(); 
    } 

    ~Qt2Func3() 
    { 
     delete slot_; 
    } 

    int qt_metacall(QMetaObject::Call c, int id, void **arguments) 
    { 
     id = QObject::qt_metacall(c, id, arguments); 
     if (id < 0 || c != QMetaObject::InvokeMetaMethod) 
      return id; 

     slot_->call(sender(), arguments); 
     return -1; 
    } 

    void connect() 
    { 
     connect_(); 
    } 

    void disconnect() 
    { 
     disconnect_(); 
    } 

private: 
    void connect_() 
    { 
     connected_ = 
      QMetaObject::connect(qobject_, signalIdx_, this, slotIdx_); 
    } 

    void disconnect_() 
    { 
     connected_ = 
      !QMetaObject::disconnect(qobject_, signalIdx_, this, slotIdx_); 
    } 


    FuncType func_; 
    Qt2FuncSlot3<SIGNATURE>* slot_; 
}; 

} 

#endif 

Así que, básicamente, que tienen que volver a implementar qt_metacall función.