Come mappare il segnale Qt all'evento in C++ gestito (C++/CLI)

Question

Sto scrivendo un wrapper in .NET (C++/CLI) per poter utilizzare un codice Qt C++ nativo in .NET. Come posso mappare un segnale Qt in un evento .NET gestito, in modo che quando il mio codice Qt attiva un segnale, posso inoltrarlo al codice .NET.

La mia classe Managed definisce l'evento, ma se provo a utilizzare il normale metodo QObject :: connect per collegarmi al segnale, è necessario un ricevitore QObject * ... Suppongo di dover eseguire un magic marshalling di alcuni tipi?

Answer 1

Definire un gestore di eventi Qt normale non gestito. Da questo gestore, aumenta l'evento gestito.

Modifica: se hai esperienza precedente in Qt, sai come gestire i segnali Qt nella classe non gestita. Non cercare di rendere questa classe gestita. Invece di questo, scrivere wrapper C++/CLI che contenga questa classe derivata da QObject.

Modifica 2. Creare applicazioni C++/CLI Console, lo chiamano test1, e aggiungere il seguente codice a esso:

test1.cpp:

 
#include "stdafx.h" 
#include "ManagedClass.h" 

using namespace System; 

int main(array ^args) 
{ 
    ManagedClass^ c = gcnew ManagedClass(); 
    c->Test(); 

    return 0; 
} 

ManagedClass.h:

 
#pragma once 

class UnmanagedClass; 

// Wrapper 
ref class ManagedClass 
{ 
public: 
    ManagedClass(void); 
    ~ManagedClass(); 
    !ManagedClass(); 
    void Test(); 
    void Callback(); 

private: 
    UnmanagedClass* m_pUnmanagedClass; 
}; 

ManagedClass.cpp:

 
#include "StdAfx.h" 
#include "ManagedClass.h" 
#include "UnmanagedClass.h" 

ManagedClass::ManagedClass(void) 
{ 
    m_pUnmanagedClass = new UnmanagedClass(this); 
} 

ManagedClass::~ManagedClass() 
{ 
    this->!ManagedClass(); 
    GC::SuppressFinalize(this); 
} 

ManagedClass::!ManagedClass() 
{ 
    if (m_pUnmanagedClass) 
    { 
     delete m_pUnmanagedClass; 
     m_pUnmanagedClass = NULL; 
    } 
} 


void ManagedClass::Test() 
{ 
    m_pUnmanagedClass->Test(); 
} 

void ManagedClass::Callback() 
{ 
    Console::WriteLine(L"This text is printed from managed wrapper function, called from unmanaged class."); 
    Console::WriteLine(L"Here you can raise managed event for .NET client."); 
    Console::WriteLine(L"Let's say that UnmanagedClass is QObject-derived, and this funcstion"); 
    Console::WriteLine(L"is called from UnmanagedClass Qt event handler - this is what you need."); 
} 

UnmanagedClass.h:

 
#pragma once 

#include 
using namespace System; 


ref class ManagedClass; 

// Wrapped native class 
class UnmanagedClass 
{ 
public: 
    UnmanagedClass(ManagedClass^ pWrapper); 
    ~UnmanagedClass(void); 
    void Test(); 

private: 
    gcroot m_pWrapper; 
}; 

UnmanagedClass.cpp:

 
#include "StdAfx.h" 
#include "UnmanagedClass.h" 
#include "ManagedClass.h" 

UnmanagedClass::UnmanagedClass(ManagedClass^ pWrapper) 
{ 
    m_pWrapper = pWrapper; 
} 

UnmanagedClass::~UnmanagedClass(void) 
{ 
} 

void UnmanagedClass::Test() 
{ 
    m_pWrapper->Callback(); 
} 

Questo vi dà un'idea di come classe non gestito e wrapper gestita possono giocare insieme. Se conosci la programmazione Qt e sai come generare eventi .NET dalla classe ref C++/CLI, questo è sufficiente per svolgere il tuo compito.