QObject::connect: Cannot queue arguments of type 'QTextCursor'

hskoglund

Hi, you can try using a more robust flavor of connect() by adding an argument after the lambda, like this:

connect(process,&QProcess::started, [this, commandName, commandLine]{print(commandName,commandLine);},Qt::BlockingQueuedConnection);

bachir

Hi,

thanks for your answer.

I tried but it doesn't compile.

no matching function for call to ‘TaskProcessor::connect(QProcess*&, void (QProcess::*)(QProcess::QPrivateSignal), TaskProcessor::proc(const QString&, const QStringList&, const QStringList&, const QMap<int, QString>&)::<lambda()>, Qt::ConnectionType)’

bachir

Finally, that works!
I have been able to compile and test.
But I don't understand, why it was not working with default Qt::AutoConnection?
The doc says : The connection type is determined when the signal is emitted.
So that means that Qt was not able to connect correctly the signal?
And why when I connect to the main window, it works without any problem??

It will be helpful if you can help me understand this weird behaviour as I am not at ease with Qt signal and slots.
Many thanks,
Bachir.

hskoglund

Hi, a good read about Qt's signal/slot is here

Re. why Qt::BlockingQueuedConnection works, just guessing, but when the connection is to a lambda, then when QProcess::started emits the signal, perhaps it cannot properly detect that the lambda's from another thread, so the connection defaults to Qt::DirectConnection (not good).

Edit: googled a bit about connect() to lambdas across threads and it looks that when the signal is emitted to a lambda the detection if it's across threads or not indeed is shaky. To avoid that, you could try a connect() to a member function of TaskProcessor instead of a lambda.

bachir

Thanks a lot for your answer, complete and clear.
Thanks again!

Bachir.

kshegunov

@hskoglund said in QObject::connect: Cannot queue arguments of type 'QTextCursor':

googled a bit about connect() to lambdas across threads and it looks that when the signal is emitted to a lambda the detection if it's across threads or not indeed is shaky.

This makes no sense Henry, a lambda is at best just a regular object it has no notion of threads to begin with. That's why you can specify context QObject (and you should) when connecting signals to lambdas.

hskoglund

@kshegunov Thanks for the clarification, it makes sense., i.e. the detection is not "shaky" it's impossible to do!

I should have a coffee and study the source code for how that detection is done when signals are emitted across threads.

And, this "problem" with connecting to lambdas across threads should be documented better I think.

kshegunov

@hskoglund said in QObject::connect: Cannot queue arguments of type 'QTextCursor':

Thanks for the clarification, it makes sense., i.e. the detection is not "shaky" it's impossible to do!

Exactly!

I should have a coffee and study the source code for how that detection is done when signals are emitted across threads.

Coffee sounds nice, I'm now envious ... ;)
You can look here about the second part:
https://code.woboq.org/qt5/qtbase/src/corelib/kernel/qobject.cpp.html#_ZN11QMetaObject8activateEP7QObjectiiPPv

And, this "problem" with connecting to lambdas across threads should be documented better I think.

Perhaps you're right, but I'm too lazy to check what it really says in the docs ... :p
However I think it's documented, probably more emphasis can be put though.

Bremenpl

@bachir Hi there,
sorry for digging this up. How did you get to compile this lambda connection with the additional argument? I still cannot do that.

This works:

		connect(uap, &CUaProxy::uaItemChanged,
				[this, i](
				const CUaProxy::MsgType msgt,
				const int riskIndex,
				const QVariant& value)
		{
			this->onUaMsgReceived(msgt, i, riskIndex, value);
		});

This doesnt compile:

		connect(uap, &CUaProxy::uaItemChanged,
				[this, i](
				const CUaProxy::MsgType msgt,
				const int riskIndex,
				const QVariant& value)
		{
			this->onUaMsgReceived(msgt, i, riskIndex, value);
		}, Qt::BlockingQueuedConnection);

Would appreciate your feedback.

Christian Ehrlicher

@Bremenpl said in QObject::connect: Cannot queue arguments of type 'QTextCursor':

This doesnt compile:

And what compiler error do you get?

Bremenpl

@Christian-Ehrlicher Sorry I didnt add it, here it is:

cintegrator.cpp:63: error: no matching member function for call to 'connect'

cintegrator.cpp:70: error: no matching function for call to 'CIntegrator::connect(CUaProxy*&, void (CUaProxy::*)(CUaProxy::MsgType, int, const QVariant&), CIntegrator::uaInit()::<lambda(CUaProxy::MsgType, int, const QVariant&)>, Qt::ConnectionType)'
   }, Qt::DirectConnection);
                          ^

qobject.h:228: error: no type named 'Object' in 'struct QtPrivate::FunctionPointer<Qt::ConnectionType>'

kshegunov

@Bremenpl said in QObject::connect: Cannot queue arguments of type 'QTextCursor':

Sorry I didnt add it, here it is

You can't have blocking queued connection (or explicitly specify the connection type for that matter) without specifying a context object. Qt can't know what's the receiving thread this is supposed to block.

Bremenpl

@kshegunov To be honest this was just an example. Originally I was aiming for Qt::DirectConnection which doesnt compile as well (same errors). How to point the context object?

kshegunov

@Bremenpl said in QObject::connect: Cannot queue arguments of type 'QTextCursor':

To be honest this was just an example. Originally I was aiming for Qt::DirectConnection which doesnt compile as well (same errors).

Give context object. Otherwise specifying a connection type makes no sense whatsoever. If the slot's to be called in the emitting thread then you can omit the connection type, and then it implies "direct". In all other cases you must know what's the receiving thread, which you can specify only through a QObject you pass as context.

How to point the context object?

https://doc.qt.io/qt-5/qobject.html#connect-5

Bremenpl

@kshegunov Right... Thanks, something didnt trigger in the brain. Now its fine:

connect(uap, &CUaProxy::uaItemChanged, this,
		[this, i](
		const CUaProxy::MsgType msgt,
		const int riskIndex,
		const QVariant& value)
{
	this->onUaMsgReceived(msgt, i, riskIndex, value);
}, Qt::QueuedConnection);

Also needed Qt::QueuedConnection eventually.