如何映射Qt信号到事件在托管C ++(C ++ / CLI) [英] How to map Qt Signal to Event in Managed C++ (C++/CLI)
问题描述
我在.NET(C ++ / CLI)中编写一个包装器,以便能够在.NET中使用一些本地C ++ Qt代码。如何将Qt信号映射到托管的.NET事件,以便当我的Qt代码触发一个信号,我可以把这转发到.NET代码。
I'm writing a wrapper in .NET (C++/CLI) to be able to use some native C++ Qt code in .NET. How can I map a Qt signal into a managed .NET event, so that when my Qt code fires off a signal, I can bring this forward to the .NET code.
My Managed类定义事件,但如果我尝试使用正常的QObject :: connect方法来连接信号,它需要一个QObject *接收器...我想我必须做一些魔法编组的一些类型?
My Managed class defines the event, but if I try to use the normal QObject::connect method to hook up to the signal, it requires a QObject * receiver... I guess I have to do some magic marshalling of some sorts?
推荐答案
定义正常的非托管Qt事件处理程序。从这个处理程序,引发托管事件。
Define normal unmanaged Qt event handler. From this handler, raise managed event.
编辑:如果你以前有过Qt的经验,你知道如何处理非托管类中的Qt信号。不要试图让这个类管理。而不是这样,编写包含此QObject派生类的C ++ / CLI包装。
if you have previous experience in Qt, you know how to handle Qt signals in unmanaged class. Don't try to make this class managed. Instead of this, write C++/CLI wrapper which contains this QObject-derived class.
编辑2.创建C ++ / CLI控制台应用程序,调用它test1,代码:
Edit 2. Create C++/CLI Console application, call it test1, and add the following code to it:
test1.cpp:
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:
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:
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:
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:
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();
}
这让你了解非托管类和托管包装器如何一起工作。如果你知道Qt编程,知道如何从ref C ++ / CLI类提高.NET事件,这足以完成你的任务。
This gives you idea how unmanaged class and managed wrapper can play together. If you know Qt programming and know how to raise .NET event from ref C++/CLI class, this is enough to accomplish your task.
这篇关于如何映射Qt信号到事件在托管C ++(C ++ / CLI)的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!