How can I totally remove the QApplication instance, so it can be possible to recreate it again in a sheared library.
If I have such a following code:
int main(int argc, char ** argv) {
QApplication *app = new QApplication(argc, argv);
MyWindow dialog;
dialog.show();
app->exec();
return 0
}
I want to be able to delete the instance after quiting the app (closing the application after app.exec())
I have tried to do the following:
app->setQuitOnLastWindowClosed(false);
app->quit();
delete app;
But non of them could be worked. I want to remove the QApplication instance like I did not create before.
The QApplication in my shared library always works if I did not define the QApplication in the main.
The library (lib) and the main application (app) are using different copy of Qt.
I am developing the app, the lib is imported to my app.
After closing the first dialog, I am using an event to trigger the thread in the library which it is waiting for this event.
You don't need to do that, because QApplication can only ever be created in the main thread. If the library and the main executable share the same Qt library, presumably the main application already created the QApplication object and will run the event loop for you. So the only thing you need to do in the library is to create some objects and the event loop will process their events.
If the main executable doesn't use Qt, then you should create the application in the main thread, prime its event loop, and let the native event loop dispatch events for you.
Alas, to directly answer your question: presumably you want to do some stuff after app.exec() returns. Your code could simply be, then:
int main(int argc, char ** argv) {
{
QApplication app{argc, argv};
MyWindow dialog;
dialog.show();
app.exec();
}
doSomething();
}
If I close the first dialog, the event loop will be left. Is it possible to keep the event loop?
Yes. You could clear the Qt::WA_QuitOnClose attribute of the first dialog. Or, preferably, set it on your dialog - the application won't quit as long as there are any dialogs with QT::WA_QuitOnClose still open.
Thus, for the second dialog, call:
secondDialog->setAttribute(Qt::WA_QuitOnClose);
Alternatively, if you don't have a pointer to the dialog, you can iterate all top-level widgets and clear (or set) the attribute on all of them:
for (auto widget : qApp->topLevelWidgets())
widget->setAttribute(Qt::QA_QuitOnClose, false);
Related
I am currently coding a program in C++/ Qt 5.9 to control a 3D Printer.
I have divided the project into several libraries :
The GUI Lib: The view
The Device Lib: Control each device (movement, printing tool, sensors)
The Controller Lib: Links the View with the Device lib
etc...
My problem is that I do not know how to initialize and terminate properly the execution of the program. More specifically, the Device library has a class named DeviceManager with two functions :
initialize() : which connect to each device and initialize them. This actions can take several seconds (10s for example)
finalize() : which closes all the connexions, can also take several seconds
What I would like to do is initialize the Device Lib in the right place without blocking the GUI and then finalize it in the right and not block the GUI
This is my main code :
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
My solution now is to call DeviceManager::initialize() in the MainWindow constructor and DeviceManager::finalize() in the MainWindow::closeEvent().
The problem: even if I use concurrency to initialize and finalize in a different thread, the application displays its window several seconds after it was launched and the display freezes when the application is closed because it has to wait for the finalize function to be done.
How should I properly handle this initialization and finalization problem, please ? Do I need to reimplement the QApplication class? Do I try and do it in the main? Do you know any great example of an open source application doing that kind of initialize and finalize work?
The problem: even if I use concurrency to initialize and finalize in a different thread, the application displays its window several seconds after it was launched and the display freezes when the application is closed because it has to wait for the finalize function to be done.
You could start the initialize() function as own detached thread before starting the MainWindow. This could cause problems if the initializing thread doesn't terminate before the first initialized "thing" is needed. Something like:
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
std::thread{initialize}.detach();
MainWindow w;
w.show();
finialize();
return a.exec();
}
To prevent the problem, and maybe lock some function in the GUI, then you probably need to have a state variable that it sets under a mutex on its way out, and which you examine under a mutex to see if it has been set.
I'm beggining with Qt and I'm currently adapting a command-line program to use it with a GUI.
I'm building my GUI like this :
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
I want to process some events permanently. In command line, I used a while loop, it work perfectly. Using Qt, I don't know how I can process these events properly.
So I tried to use a std::thread, but my Qt app crashes when I try to modify the GUI from the thread. Same problem using QThread.
I don't need threading, so it would be great if I can just put my code in the Qt's main thread.
Anyone can help me please ?
You could use a QTimer connected to a slot in your MainWindow class to run a function periodically like this :
MainWindow::MainWindow()
{
myTimer = new QTimer();
myTimer->setSingleShot(false);
myTimer->start(intervalInMilliseconds);
connect(myTimer, &QTimer::timeout, this, &MainWindow::handleMyEvents);
}
void MainWindow::handleMyEvents()
{
// Your code here
}
You could also use threads, but note that you must not call any GUI code from any thread that isn't the QApplication thread, this is probably why your attempt crashed.
When QML engine creates window it implicitly connects QQuickWindow to application's closing event so if I close QML windows application quits too. Is there a way to avoid this behavior?
I want periodically to load and destroy instances of QQuickWindow so that will not close my application.
You can use setQuitOnLastWindowClosed in QGuiApplication. The property indicates whether the application should quit when the last window is closed or not. The default value is true, you can change it to false.
Your main can be like :
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
qApp->setQuitOnLastWindowClosed(false);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:///main.qml")));
return app.exec();
}
Do I miss any Qt functionality if I substitute QApplication::exec() with standard Windows message loop implementation? This should clarify what I mean:
The ususal “Qt” way to run event processing:
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
Window w;
w.show();
return a.exec();
}
“Windows” way to run event processing:
#include <Windows.h>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
Window w;
w.show();
MSG msg;
while(GetMessage(&msg, 0, 0, 0)){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
The above demonstrates having external message loop with respect to QApplication instance, while QApplication instance itself doesn’t even have its own event loop at all.
In other words, if I have main.exe program (knowing nothing about Qt) with message loop and a .dll with Qt GUI and QApplication instance inside, will it be ok to let the external message loop from main.exe to handle events for Qt GUI?
Thanks in advance!
EDIT 1:
I’ll just answer myself in case it’s usefull for somebody:
We have a main .exe module written in C# under .NET that runs event loop processing, and we have a couple of .dlls written in Qt/C++ that have a GUI “inside” (and a QApplication instance that is shared). QApplication::exec() is never called but all the events are successfully dispatched by the main .exe (.NET) module’s event loop and all the Qt functionallity is present( signals/slots, threads, etc.)
EDIT 2:
That worked for Qt 4.8.2 but for Qt 5.1.0 things are a little bit different. Now you have to call QApplication::processEvents() once because it performs some initial initialization on its first call( installs WindowsHook on GetMessage or PeekMessage ). And after that whoever calls GetMessage in your application Qt events get processes and you are golden :)
The first thing which comes to my mind is that calling slots across threads won't work because the Qt event loop is executing those calls.
But the more important question is probably: Why do you want to do it like this especially since in qeventdispatcher_win.cpp is doing essentially the same thing?
I have the following source code:
Processmethod()
{
QDialog *ProcessMessage = new QDialog;
Ui::DialogProcessMessage Dialog;
Dialog.setupUi(ProcessMessage);
ProcessMessage->setModal(true);
ProcessMessage->setAttribute(Qt::WA_DeleteOnClose);
ProcessMessage->show();
PROCESSES START
}
After I want to show the QDialog "ProcessMessage" there are three QProcess processes included in three different following methods. If I disable these methods with // the popup window appears just fine, but if I enable the methods, the processes run fine, but the popup window does not appear. Any ideas/solutions ? greetings
Your window do not show until Process method is not return because main application loop implemented in main function
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QDialog w; // or other window
w.show();
return a.exec(); // main app loop (all drawing procedures called from here
}
So if you call your PROCESSES START nothing happened until Process method returns in QApplication::exec()
You can start your processes in separate thread and send progress notification to you dialog by implementing signals\slots in queued mode
The dialog cannot be shown until your code execution exits ProcessMethod(). If you are using the QProcesses synchronously (by calling any of the waitForXXX methods), then this would cause the problem you are seeing. Anything else that holds up the main thread would also cause this problem.