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



  • Hi everyone,

    I have a issue that I was not able to solve. Can anyone help me please?

    QObject::connect: Cannot queue arguments of type 'QTextCursor'
    (Make sure 'QTextCursor' is registered using qRegisterMetaType().)

    The weird part is that I am not declaring at all an object of type 'QTextCursor'.

    I have a controller class, implemented as a singleton that instantiate processes :

    • taskprocessor.cpp
    #include "taskprocessor.h"
    
    TaskProcessor *TaskProcessor::instance = new TaskProcessor();
    
    TaskProcessor *TaskProcessor::getInstance() {
        return instance;
    }
    
    TaskProcessor::TaskProcessor() : QObject() {
    }
    
    QProcess *TaskProcessor::proc(const QString &program, const QStringList &arguments, const QStringList &dispargs,  const QMap<int, QString> &display) {
        // instantiate a new process
        QProcess *process = new QProcess();
        // set the program to process
        process->setProgram(program);
        // set the program arguments
        process->setArguments(arguments);
        // display the command on started
        QString commandName = display.value(DISPLAY_COMMAND);
        QString commandLine = program+" "+dispargs.join(" ");
        connect(process,&QProcess::started, [this, commandName, commandLine]{print(commandName,commandLine);});
        // return the process instance
        return process;
    }
    
    void TaskProcessor::print(const QString &commandName, const QString &commandLine) {
        // display the command name
        if (!commandName.isEmpty())
            emit printInfo(commandName);
        // display the command line
        emit printLog(commandLine);
    }
    
    • taskprocessor.h
    #ifndef TASKPROCESSOR_H
    #define TASKPROCESSOR_H
    
    #include <QProcess>
    #include <QObject>
    #include <QMap>
    
    // the display string
    #define DISPLAY_COMMAND 0
    #define DISPLAY_SUCCESS 1
    #define DISPLAY_ERROR -1
    
    /**
     * @class TaskProcessor
     * @brief The task processor class
     * Generate the tasks process
     */
    class TaskProcessor : public QObject
    {
        Q_OBJECT
    
        public:
            /**
             * @brief Get the class instance
             * @return The class instance
             */
            static TaskProcessor *getInstance();
            /**
             * @brief Process a new program with its arguments
             * @param program The program
             * @param arguments The arguments
             * @param dispargs The arguments to display
             * @param display The strings to display
             * @return The process
             */
            QProcess *proc(const QString &program, const QStringList &arguments, const QStringList &dispargs, const QMap<int,QString> &display);
    
        private:
            /**
             * @brief The class instance
             */
            static TaskProcessor *instance;
            /**
             * @brief The default constructor
             */
            TaskProcessor();
            /**
             * @brief Display the command
             * @param commandName The command name
             * @param commandLine The command line
             */
            void print(const QString &commandName, const QString &commandLine);
    
        signals:
            /**
             * \brief Print a error message in the console
             * \param message The message
             */
            void printError(QString message);
            /**
             * \brief Print a log message in the console
             * \param message The message
             */
            void printLog(QString message);
            /**
             * \brief Print an info message in the console
             * \param message The message
             */
            void printInfo(QString message);
            /**
             * \brief Print an success message in the console
             * \param message The message
             */
            void printSuccess(QString message);
    };
    
    #endif // TASKPROCESSOR_H
    
    

    And I have of course a main window class

    • mainwindow.cpp
    #include "mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent)
    {
        /* The task processor */
        TaskProcessor *taskProcessor = TaskProcessor::getInstance();
        connect(taskProcessor, &TaskProcessor::printError, [this](QString message){consolePrint(message, ConsoleMsgType::error);});
        connect(taskProcessor, &TaskProcessor::printLog, [this](QString message){consolePrint(message);});
        connect(taskProcessor, &TaskProcessor::printInfo, [this](QString message){consolePrint(message,ConsoleMsgType::info);});
        connect(taskProcessor, &TaskProcessor::printSuccess, [this](QString message){consolePrint(message,ConsoleMsgType::success);});
    
        /* The console */
        consoleDock = new QDockWidget(this);
        console = new QTextEdit(consoleDock);
        console->setTextColor(Qt::white);
        QPalette p = console->palette();
        p.setColor(QPalette::Base, QColor(20,0,20));
        console->setPalette(p);
        console->setReadOnly(true);
        consoleDock->setWidget(console);
        consoleDock->setAllowedAreas(Qt::BottomDockWidgetArea);
        consoleDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
        addDockWidget(Qt::BottomDockWidgetArea, consoleDock);
        setCorner(Qt::BottomLeftCorner, Qt::BottomDockWidgetArea);
        setCorner(Qt::BottomRightCorner, Qt::BottomDockWidgetArea);
    }
    
    void MainWindow::consolePrint(QString msg, ConsoleMsgType mtype){
        QString endMsg;
        switch(mtype){
            case log:
                endMsg = "<span style='color:white'>";
                break;
            case error:
                endMsg = "<span style='color:red'>";
                break;
            case info:
                endMsg = "<span style='color:cyan'>";
                break;
            case warning:
                endMsg = "<span style='color:orange'>";
                break;
            case success:
                endMsg = "<span style='color:lime'>";
                break;
        }
    
        endMsg += msg + "</span>";
    
        console->append(endMsg);
    }
    

    My code is clearly more complex but I am just giving the relevant part.

    • When the process generated by the class TaskProcessor is executed on the same thread, everything is fine : the command is printed in the console and no error message appears.
      BUT
    • When the same process is executed on another thread, I have the error message (see below) and the command is still printed in the console. Yet, the first line is invisible and this line becomes visible only if we click on it! Very weird!

    QObject::connect: Cannot queue arguments of type 'QTextCursor'
    (Make sure 'QTextCursor' is registered using qRegisterMetaType().)

    So it seems to be a multi-threading issue caused by this instruction connect(process,&QProcess::started, [this, commandName, commandLine]{print(commandName,commandLine);});. However:

    • If I connect directly the process started signal to the main window, and even if the process is started from another thread, it is all right. No message error;
    • The class instance of TaskProcessor is on the same thread that the class instance of MainWindow;
    • If the last line console->append(endMsg); is commented, I have no more error message (and there is no more print on the console...).

    I have tried registering QTextCursor with qRegisterMetaType, but it doesn't help;

    Anyone can tell what I am doing wrong, and how to fix that? Many thanks.

    Bachir.



  • 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);


  • 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)’



  • 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.



  • 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.



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

    Bachir.


  • Qt Champions 2017

    @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.



  • @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.


  • Qt Champions 2017

    @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.



Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.