q_disable_copy - Creando una ranura dinámica en Qt

qt object connect

Question

Estoy intentando crear slots dinámicamente y conectarlos. Soy capaz de crear dinámicamente PushButtons y conectarlos con las ranuras existentes. Pero, ¿qué sucede si tengo una clase con algunas funciones miembro y quiero usar estas funciones como espacios?

Desde una perspectiva general, quiero crear una plantilla para generar espacios dado un puntero a la función. Esto nos permite crear ranuras sin cambiar el código existente y no tenemos que volver a compilar usando MOC. Si esto no tiene sentido, házmelo saber. Gracias.

-CV

Answer 1

Una continuación del código de andref para usar cualquier función miembro como un espacio

 class SlotForwarder : public QObject
{
Q_OBJECT
public:
typedef void (*Function)();
SlotForwarder(Function function, QObject* parent = 0)
: QObject(parent)
, m_fptr(function)
{}
public slots:
void forward()
{
m_fptr();
}
private:
Function m_fptr;
};
int main(){
QApplication a(argc, argv);
MyClass myClassObject; //contains a function called MemberFunc
//create a slotforwarder object so
SlotForwarder *memberFuncSlot = new SlotForwarder (std::tr1::bind(&MyClass::MemberFunc, &myClassObject));
QObject::connect(ui.button,SIGNAL(clicked()),memberFuncSlot,SLOT(forward());
}

Answer 2

Tiene mucho sentido. Supongo que QSignalMapper no es lo que quieres. Si sus funciones no tienen argumentos, tal vez algo como esto sea suficiente:

class SlotForwarder : public QObject
{
Q_OBJECT
public:
typedef void (*Function)(); // or whatever. I never get this syntax right...
SlotForwarder(Function function, QObject* parent = 0)
: QObject(parent)
, m_fptr(function)
{}
public slots:
void forward()
{
m_fptr();
}
private:
Function m_fptr;
};

Cree uno para cada función que quiera encapsular y conéctese al forward como de costumbre.

Ahora, si tienen argumentos, tal vez este artículo trimestral de Qt pueda ser de ayuda.

Señales dinámicas y ranuras de Eskil A. Blomfeldt

La técnica implica qt_metacall método qt_metacall usted mismo. El método tiene esta firma:

int QObject::qt_metacall(QMetaObject::Call call, int id, void **arguments)

La llamada es el tipo de metacall: ranura, señal, propiedad de lectura o escritura, etc. Cada ranura tiene una identificación . Los parámetros están empaquetados (por valor o como punteros) dentro de la matriz de argumentos . Leer el código que genera el moc es una buena forma de entender cómo funciona todo.

Los datos sobre las firmas de funciones sin procesar están disponibles solo durante el tiempo de compilación, pero las ranuras se resuelven en tiempo de ejecución. Debido a esa falta de coincidencia, deberá ajustar las funciones en un tipo de adaptador de plantilla que presente una interfaz constante para su implementación de qt_metacall y convierta la matriz de arguments en algo que la función pueda entender ( consulte el operador de desempaquetado de Python). Boost.Signals hace ese tipo de piratería de plantilla .