Anzeigen und erhalten das Ergebnis einer QMessageBox von außerhalb eines QObject

Question

Ich versuche, das Ergebnis anzeigen und erhalten ein Meldungsfeld von außerhalb einer QObject-Klasse. Ich scheine in der Lage sein den Dialog wie folgt zu generieren:

#include <iostream> 

#include <QApplication> 
#include <QtConcurrentRun> 
#include <QMessageBox> 

class DialogHandler : public QObject 
{ 
Q_OBJECT 

signals: 
    void MySignal(); 

public: 
    DialogHandler() 
    { 
    connect(this, SIGNAL(MySignal()), this, SLOT(MySlot())); 
    } 

    void EmitSignal() 
    { 
    emit MySignal(); 
    } 

public slots: 
    void MySlot() 
    { 
    QMessageBox* dialog = new QMessageBox; 
    dialog->setText("Test Text"); 
    dialog->exec(); 
    int result = dialog->result(); 
    if(result) 
    { 
     std::cout << "ok" << std::endl; 
    } 
    else 
    { 
     std::cout << "invalid" << std::endl; 
    } 
    } 
}; 

#include "main.moc" // For CMake's automoc 

void MyFunction(DialogHandler* dialogHandler) 
{ 
    dialogHandler->EmitSignal(); 
} 

int main(int argc, char *argv[]) 
{ 
    QApplication app(argc, argv); 

    DialogHandler* dialogHandler = new DialogHandler; 

    MyFunction(dialogHandler); 

    return app.exec(); 
} 

Um das Ergebnis zurück in MyFunction zu bekommen, scheint es zu funktionieren einfach zu tun, ein Objekt übergeben, mit dem Ergebnis so füllen:

#include <iostream> 

#include <QApplication> 
#include <QtConcurrentRun> 
#include <QMessageBox> 

class DialogHandler : public QObject 
{ 
Q_OBJECT 

signals: 
    void MySignal(int* returnValue); 

public: 
    DialogHandler() 
    { 
    connect(this, SIGNAL(MySignal(int*)), this, SLOT(MySlot(int*)), Qt::BlockingQueuedConnection); 
    } 

    void EmitSignal(int* returnValue) 
    { 
    emit MySignal(returnValue); 
    } 

public slots: 
    void MySlot(int* returnValue) 
    { 
    std::cout << "input: " << *returnValue << std::endl; 
    QMessageBox* dialog = new QMessageBox; 
    dialog->addButton(QMessageBox::Yes); 
    dialog->addButton(QMessageBox::No); 
    dialog->setText("Test Text"); 
    dialog->exec(); 
    int result = dialog->result(); 
    if(result == QMessageBox::Yes) 
    { 
     *returnValue = 1; 
    } 
    else 
    { 
     *returnValue = 0; 
    } 
    } 
}; 

#include "main.moc" // For CMake's automoc 

void MyFunction(DialogHandler* dialogHandler) 
{ 
    int returnValue = -1; 
    dialogHandler->EmitSignal(&returnValue); 

    std::cout << "returnValue: " << returnValue << std::endl; 
} 

int main(int argc, char *argv[]) 
{ 
    QApplication app(argc, argv); 

    DialogHandler* dialogHandler = new DialogHandler; 

    QtConcurrent::run(MyFunction, dialogHandler); 

    std::cout << "End" << std::endl; 
    return app.exec(); 
} 

Scheint das vernünftig? Gibt es einen besseren Weg, es zu tun?

Answer 1

Dies ist nicht möglich, wie Sie es haben, aber mit ein wenig Arbeit könnte es getan werden. Eine Option wäre natürlich, Ihre Klasse in ein QObject zu konvertieren, an dem Sie Signale senden könnten. Es hilft jedoch nicht für die Verzögerung während der Ausführung. Wenn dies erforderlich ist, können Sie eine Nachrichtenklasse verwenden, die im Hauptthread der Benutzeroberfläche enthalten ist, aber von anderen Threads aus aufgerufen werden kann. Die von anderen Threads aufgerufene Funktion müsste sperren, einen Semaphor erzeugen und ein Ereignis an sich selbst senden, wobei der Semaphor und die Nachricht angezeigt werden. Dann würden Sie in customEvent (das im UI-Thread enthalten wäre) das Meldungsfeld erstellen, es ausführen und das Semaphor auslösen, nachdem das Meldungsfeld gelöscht wurde.

Natürlich wird es etwas komplizierter, wenn Sie Informationen auch andersherum senden müssen. Dann brauchst du ein komplettes Subsystem für dein Programm, anstatt nur eine Basisklasse, wie ich sie hier beschreibe.