Qt Slot Execution Order
Qt Signals and slots can be very useful. Together with a model-view-controller framework, where the model emits signals to views and controllers, a very clean and logical system can unfold. However, one must be aware of a couple of pitfalls. First, there is no control over the order in which slots are called from signals. Detailed Description. The QObject class is the base class of all Qt objects. QObject is the heart of the Qt Object Model.The central feature in this model is a very powerful mechanism for seamless object communication called signals and slots. ###Overview Qt provides QSqlQuery class for synchronous database access. Often asynchronous and threaded database access is desired. QtAsyncSql provides a implementation for asynchronous database access using the Qt Api. Asynchronous SQL queries with Qt's SIGNAL and SLOT mechanism. Database access from distinct threads. Traditional syntax: SIGNAL and SLOT QtCore.SIGNAL and QtCore.SLOT macros allow Python to interface with Qt signal and slot delivery mechanisms. This is the old way of using signals and slots. The example below uses the well known clicked signal from a QPushButton. The connect method has a non python-friendly syntax. In this tutorial we will learn How to use signal and slots in qt. File-New File or Project Applications-Qt Gui Application-Choose We keep the class as MainWindow as given by default.
Qt is a cross-platform C++ framework for creating GUI applications. Qt uses its own build system, qmake, and also supports building with CMake starting from the version Qt4.
A pure Qmake project can't be imported in CLion directly. However, when converted into CMake, it can be opened and managed as a regular CMake application. You can also create a CMake-based Qt project in CLion using the New Project wizard.
Another option to open a Qt project is to use a compilation database. You can generate compile_commands.json for your qmake project with the help of scan-build or via the Build Generate Compilation Database action in Qt Creator, then open this file as a project in CLion and add custom build targets and custom Run/Debug configurations for it.
CMake-based Qt projects
For CMake version 3.0 and newer, Qt ships the modules that let CMake find and use Qt4 and Qt5 libraries. Take the following steps to configure CMakeLists.txt for your Qt project.
CMakeLists.txt for a Qt project
Add the
find_package
command to locate the required libraries and header files. For example:Then, use
target_link_libraries
to make your target dependent on these libraries and headers:target_link_libraries(helloworld Qt5::Widgets)For
find_package
to perform successfully, CMake should be instructed on where to find the Qt installation.One of the ways to do this is by setting the
CMAKE_PREFIX_PATH
variable. You can either pass it via-D
in the CMake settings dialog or via theset
command beforefind_package
.For example, in the case of MinGW on Windows:
set(CMAKE_PREFIX_PATH 'C:QtQt5.14.05.14.0mingw73_32')If your project uses MOC, UIC, or RCC, add the following lines to enable automatic invocation of the corresponding compilers:
set(CMAKE_AUTOMOC ON) set(CMAKE_AUTOUIC ON) set(CMAKE_AUTORCC ON)List all the .ui and .qrc files in the
add_executable()
command along with your .cpp sources:add_executable( helloworld main.cpp mainwindow.cpp application.qrc)
Below you can find the full CMakeLists.txt script for a simple 'Hello, world' application:
Setting up a Qt project in CLion
Qt Slot Execution Order Diagram
Toolchains on Windows
When installing Qt on Windows, pick the distributive that matches the environment you are using in CLion, MinGW or MSVC.
For MinGW, both the version and the bitness (32-bit MinGW or MinGW-w64) should match with your toolchain setup.
In CLion, go to Settings(Ctrl+Alt+S), navigate to Build, Execution, Deployment Toolchain and select the toolchain that matches your Qt installation.
If you have several Qt installations, make sure to select the same toolchain as the one you specified in
CMAKE_PREFIX_PATH
.As an example, in the case of MinGW:
For details on Windows toolchains, take a look at the MinGW or MSVC section of our Windows Tutorial.
CMake settings
Qt projects are handled as regular CMake projects in CLion, so you can configure CMake settings in Settings/Preferences Build, Execution, Deployment CMake as necessary.
For example, you can create different CMake profiles with different build types and set up CMake generators of your choice.
In this dialog, you can also specify CMake options, such as
CMAKE_PREFIX_PATH
instead of setting them in CMakeLists.txt:
Debugger renderers
You can use Qt type renderers in CLion, however, for now, you need to set them manually either using the gdbinit/lldbinit scripts or, in the case of MSVC, via native visualizers.
Windows MSVC
CLion’s debugger for the MSVC toolchain can employ native visualizers if you have them in your project. Make sure to set the Enable NatVis renderers for LLDB option in Settings Build, Execution, Deployment Debugger Data Views C/C++.
For example, try copying qt5.natvis under your project root - CLion will detect and use it automatically.
Windows MinGW / macOS / Linux
For non-MSVC toolchains, a solution would be to configure the Qt renderers via .gdbinit/.lldbinit. These scripts are loaded on every invocation of GDB or LLDB, respectively. Try KDevelop formatters for GDB, KDevelop formatters for LLDB, or Lekensteyn's qt5printers (GDB).
Editing UI files in Qt Designer
By default, CLion opens .ui files in the editor. You can change this behavior in order to edit .ui files right in Qt Designer.
Go to Settings / Preferences Editor File Types, select Qt UI Designer Form from the Recognized File Types list, and delete the associated file extension.
Next time you click a .ui file for opening, set the Open in associated application checkbox, and the files of this type will always open in Qt Designer.
Creating a CMake-based Qt project
CLion provides two project templates for Qt: Qt Console Executable and Qt Widgets Executable.
Call File New Project and select the project type in the left-hand pane. Specify the location, language standard, and Qt version. You can also provide the path to be used in CMAKE_PREFIX_PATH
. Click Create when ready.
CLion will generate a ready-to-go stub project with CMakeLists.txt filled in automatically, including the CMAKE_PREFIX_PATH
variable:
Qt UI class templates
You can quickly create a Qt class with the corresponding .ui, .cpp, and .h files.
In the Project view, select New from the context menu or press Alt+Insert. Choose Qt UI Class:
In the dialog that opens, fill in the class name and configure the following settings:
Filename base - specify the name for the .ui/.cpp/.h files to be generated.
Parent class - select
QWidget
,QMainWindow
, orQDialog
as the parent class.Add to targets - set this checkbox to automatically add the new files to the list of sources for the selected target(s).
CLion will generate the .ui, .cpp, and .h files following the templates defined in Settings / Preferences Editor File and Code Templates: Qt Designer Form, Qt Class, and Qt Class Header, respectively. If required, you can adjust these templates for your needs.
Qt-specific code insight
CLion provides code completion for Qt signals and slots, filtering the suggestion list to show only the corresponding members:
Completion works for the SIGNAL()
and SLOT()
macros as well:
Also, CLion's auto-import supports Qt-style header files, offering the shortest possible #include
:
Current limitations
Two umbrella tickets in CLion tracker: Qt project support (CPP-318) and Qt issues (CPP-1897).
Some of the CLion's code generation features may not work for Qt macros, such as
Q_PROPERTY
,Q_SIGNAL
,Q_SLOT
, and others.Although QML is not supported in CLion out of the box (see the feature request), you can try the QML Support plugin.
Troubleshooting
If you get the Process finished with exit code -1073741515 (0xC0000135) error message when running on MinGW, the issue might relate to Qt deployment on Windows: dynamic libraries and Qt plugins must be found from the directory of the running binary. One of the possible workarounds is described below.
Copy the .dll-s located in bin under the MinGW directory in the Qt installation to your project’s generation folder, which is cmake-build-debug or cmake-build-release by default.
The libraries you will most likely need are libstdc++-6.dll, Qt5Widgets.dll, Qt5Gui.dll, and Qt5Core.dll, but your setup might require other libraries as well.
In the settings of the configuration you use for running, set the
QT_QPA_PLATFORM_PLUGIN_PATH
environment variable to pluginsplatforms under the MinGW directory:Another option is to copy the contents of pluginsplatforms to cmake-build-debug(release)/platforms (make sure to create the platforms directory).
Refer to the Qt Plugins documentation for more details.
- Status:Closed
- Resolution: Invalid
- Fix Version/s: None
- Labels:
- Environment:Ubuntu 16.04 and Windows 10 both using Qt 5.9.1
Summary
The order of event execution differs between Linux and Windows for mousePressEvent, mouseReleaseEvent, and contextMenuEvent.
Description
Attached is a small qt project that will reproduce the issue. It is just a QPushButton that prints when it receives the above-mentioned events.
Note: On windows I had to #undef main before the main function to get it to compile.
Expected behavior:
Qt Signal Slot Execution Order
The events are processed in the same order on Linux and Windows.
Actual behavior:
When right clicking the widget that appears, on Linux the events will be processed in the following order:
MOUSE DOWN
CONTEXT MENU
MOUSE UP
On Windows the events will be processed in the following order:
MOUSE DOWN
MOUSE UP
CONTEXT MENU
Environment
Linux:
$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 16.04.2 LTS
Release: 16.04
Codename: xenial
Qt Version: 5.9.1 (installed from qt installer)
Windows:
OS: Windows 10
Qt Version: 5.9.1 (installed from qt installer)
Attachments
Gerrit Reviews
- Assignee:
- Gatis Paeglis
- Reporter:
- Christopher Pezley
- Votes:
- 0Vote for this issue
- Watchers:
- 2Start watching this issue