Signal Slot Qt Qml
I've created an item, that contains a button. I'm trying to close parent window of item with this button, but I'm getting this message, when click the item:
TypeError: Property 'close' of object QQuickRootItem(0x1d8efed8) is not a function
The Cascades framework uses signals and slots to allow objects to communicate with each other. This system is based on the signals and slots mechanism that the underlying Qt development framework uses for inter-object communication. The signals and slots mechanism is how Cascades manages event handling. In other frameworks, you might design. Are there some changes between Qt5.2 and Qt5.3 regarding to signal and slots behaviour? I've tried to switch to Qt5.3 but my Signals and Slots with QVariant are not working between QML and C. I've written a small example that is working fine with Qt5.2 but not with Qt5.3.
- It is rather used for more complex data, such as custom Widgets, Canvas or Video elements that QML does not natively support or extended QStandardItemModels. It is a more convenient way to exchange data between QML and C and does not need Signals or Slots in first instance, because the QStandardItemModel updates the GUI automatically.
- A signal is automatically emitted when the value of a QML property changes. This type of signal is a property change signal and signal handlers for these signals are written in the form onChanged where is the name of the property, with the first letter capitalized. For example, the MouseArea type has a pressed property.
- Qt already provides signals and slots for its classes, which you can use in your application. For example, QPushButton has a signal clicked , which will be triggered when the user clicks on the button. The QApplication class has a slot quit function, which can be called when you want to terminate your application.
Can you help me with this?
Code of item:
Code for window:
That seems a bit messy. If I were you, I'd add a clicked signal to the custom button type. For example:
Item:
Window:
This provides the flexibility of using your custom BackButton type in other ways in the future.
QWidget.paintevent() vs QLabel.setPixmap()
qt,qwidget,qlabel
I would override MonitoringWidget::paintEvent() and then use the monitored widget's QWidget::render() to render the monitored widget into the MonitoringWidget. This should roughly be equivalent to what the widget being monitored itself will do when it receives paint events. Also you probably need some link between the monitored widget and the...
Loading animated gif data in QMovie
json,qt,pyside,animated-gif
This looks like a PySide bug, as the same code works perfectly fine in PyQt. The bug seems to be in the QMovie constructor, which does not read anything from the device passed to it. A work-around is to set the device explicitly, like this: import sys from PySide import...
Qt can't assign value to QLabel
c++,qt
The issue is with following signal slot connection. QObject::connect(calculate, SIGNAL(clicked()), &prog, SLOT(results->setNum(value(*spinner));)); You are trying to connect the clicked() signal of calculate button to results->setNum(value(*spinner)); slot of prog. But results->setNum(value(*spinner)); is not actually a slot. A slot is simply a method in a class that inherits QObject. Method should be...
How to manipulate multiple Folders/Dir in QT?
c++,qt,qmediaplayer,qdir,qfileinfo
If i understood correctly you want something like this: My code is a bit rough but you can use it as starting point: -MainWindow.h: #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QComboBox> namespace Ui { class MainWindow; } class MainWindow : public QMainWindow { Q_OBJECT public: explicit MainWindow(QWidget *parent =...
Rotating a Label In Qt with Python
python,qt
Not 100% sure what you're trying to achieve, but rotating the image / pixmap and leaving the label's paintEvent unchanged seems easier: # load your image image = QtGui.QPixmap(_fromUtf8(':/icons/BOOM_OUT.png')) # prepare transform t = QtGui.QTransform() t.rotate(45) # rotate the pixmap rotated_pixmap = pixmap.transformed(t) # and let the label show the...
QT Combo Box of Line Pattern
c++,qt,qcombobox
Easy way: comboBox->setIconSize(QSize(100, 24)); comboBox->addItem(lineIcon, '); comboBox->addItem(dotLineIcon, '); comboBox->addItem(dashLineIcon, '); ... Correct way: comboBox->setItemDelegate(...); ...
C++ & Qt: Random string from an array area
c++,arrays,string,qt,random
You should use the random header. #include <random> std::default_random_engine generator; std::uniform_int_distribution dist(0, 5); int StringIndex = dist(generator); std::string ChosenString = characters[StringIndex]; The above will generate a random index into your array. If you want to limit the range, change the constructor of dist, for example (dist(0,2) would only allow for...
Unable to connect to mariadb database server with qt 4.8.5 and Ubuntu 12.04
mysql,qt,ubuntu,mariadb
It was a problem with the database and not the Qt application, the connection refused if a password was used.
load a thumbnail on QListWidget with reduced resolution
image,qt,qlistwidget,qlistwidgetitem
Use QImage first to scale the image and construct the icon from the resulting pixmap. QSize desiredSize; Qimage orig(filesToLoad[var]); Qimage scaled = orig.scaled( desiredSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); QListWidgetItem *listItem = new QListWidgetItem(QIcon(Qpixmap::fromImage(scaled)),filename); It is very common to store the presized image too on the disk, to avoid the two step conversion...
How to pass QString variable to QFile?
qt,qstring,qfile
QString selected = model2->filePath(index); does not set the variable in the (maybe same named) member OptionsDialog::selected. This creates a new local variable. If you have a member variable called selected then you should use it like this: void OptionsDialog::getData(const QModelIndex &index) { selected = model2->filePath(index); ... } ...
Deploying to Android results in file not found after adding QtQuick Controls
android,qt,deployment,qml,qt5.4
When deploying the application, androiddeployqt will copy a bunch of files which terribly fails on Windows when source or destination paths become longer than 260 characters (yeah, that's a 'known feature'). Keeping the Qt installation and the project directory as top level as possible helps to reduce the path lengths...
Align horizontalcenter in Column
qt,qml,qtquick2,qt-quick
I suppose you can use anchors.horizontalCenter for all the child items to align them with the horizontalCenter of the column given that the column has an id you can refer to.
Sorting based on the rules set by a string variable
c++,qt,sorting,c++11
You can make a map between their choice and a functor to sort by, for example using SortFun = bool(*)(Hotel const&, Hotel const&); std::map<char, SortFun> sorters { {'s', [](Hotel const& lhs, Hotel const& rhs){ return lhs.stars < rhs.stars; }}, {'f', [](Hotel const& lhs, Hotel const& rhs){ return lhs.freeRoomCount < rhs.freeRoomCount;...
Updating ac value for Qtimer
qt,user-interface,adc
Hopefully this will get you started - it creates a timer which times out every 1000 milli seconds. The timer's timeout signal is connected to the same slot that your PushButton1 is connected to - starti2c. QTimer *timer = new QTimer(this); connect(timer, SIGNAL(timeout()), this, SLOT(starti2c())); timer->start(1000); That code should be...
How to change the opacity of Qt MainWindow?
qt,qmainwindow
The below works for me most of times (as long as we can run in stylesheet override problem with other ways). Consider change the last component of rgba to less than 255 for making it semi-transparent. widget->setStyleSheet('background-color: rgba(255, 255, 255, 255);'); Mind that child widgets may inherit the transparent background...
Update bindings to var properties in QML
qt,qml
Actually, the page does say how to work around this: If the onCompleted handler instead had 'car = new Object({wheels: 6})' then the text would be updated to say 'The car has 6 wheels', since the car property itself would be changed, which causes a change notification to be emitted....
Return const reference to local variable correctly
c++,qt
It doesn't work. That way you simply suppress the warning by making the situation harder to analyze. The behavior is still undefined.
Id in database using qt
database,qt,sqlite
The method you're looking for is QSqlQuery::lastInsertId(). To quote the documentation: Returns the object ID of the most recent inserted row if the database supports it. An invalid QVariant will be returned if the query did not insert any value or if the database does not report the id back....
What does QHeaderView::paintSection do such that all I do to the painter before or after is ignored
Qt Signal Slot C++ Qml
c++,qt,qpainter,qheaderview
It is obvious why the first fillRect doesn't work. Everything that you paint before paintSection is overridden by base painting. The second call is more interesting. Usually all paint methods preserves painter state. It means that when you call paint it looks like the painter state hasn't been changed. Nevertheless...
How can I override the member of (->) operator of a base class
c++,qt,inheritance,overloading,operator-keyword
As I eventually realised above, this isn't possible. The operator ->() has to return the type upon which it is acting, and for that reason it can't be used as a virtual function.
How can I make a QTextEdit widget scroll from my program
c++,qt
Here is what I found as a suitable solution: The vertical scrollbar may be accessed using the QTextEdit::verticalScrollBar() method. Scrollbars have a triggerAction() method to conveniently simulate user interaction with the buttons and the slider. The available actions are defined in QAbstractSlider. So the resulting code is only a single...
Customizing QDateEdit style
c++,qt
It comes close to the image you've posted: QDateEdit { background-color: white; border-style: solid; border-width: 4px; border-color: rgb(100,100,100); spacing: 5px; } QDateEdit::drop-down { image: url(:/new/myapp/cbarrowdn.png); width:50px; height:15px; subcontrol-position: right top; subcontrol-origin:margin; background-color: white; border-style: solid; border-width: 4px; border-color: rgb(100,100,100); spacing: 5px; } Maybe the key-word here is 'sub-control'. The arrows...
QtQuick2 - QML - create infinite moving line animation
javascript,animation,qml,infinite-scroll,qtquick2
Something like that? Rectangle { width: 400 height: 30 anchors.centerIn: parent border.color: 'grey' border.width: 1 clip: true Rectangle { id: runner property double percent: 0.2 width: parent.width * percent height: parent.height color: 'orange' NumberAnimation on x { from: runner.width * (-1); to: 400; duration: 2000; loops: Animation.Infinite } } }...
change QDir::rootPath() to program running path?
c++,qt
QCoreApplication::applicationDirPath() returns the exact directory path of your app, for example H:/programs if your app path is H:/programs/ftpserver.exe so if you modify that QString you can get the root dir. For example: QString rootPath = QCoreApplication::applicationDirPath(); rootPath.chop(rootPath.length() - 3); //we leave the 3 first characters of the path, the root...
Change attribute value of an XML tag in Qt
c++,xml,qt
I guess, but I think your XML is only present in your memory. You have to trigger somethink like tsFileXml.WriteToFile(filename) to store your changes to a file on your filesystem.
How to add a gif image in the statusbar Qt [closed]
c++,qt
You can add a QLabel, with a QMovie in it. QLabel label; QMovie *movie = new QMovie('animations/fire.gif'); label.setMovie(movie); movie->start(); You can then add the label to the using QStatusBar::addWidget() like so: statusBar()->addWidget(&label); ...
std::ostream to QString?
c++,qt,exception
You can use an std::stringstream as follows: std::stringstream out; // ^^^^^^ out << 'Error in void Cat::eat(const Bird &bird): bird ' << bird << ' has negative weight' << std::endl; throw(QString::fromStdString(out.str())); // ^^^^^^^^^^^^^^^^^^^^^^^^^^ Specifically, the std::stringstream::str member function will get you an std::string, which you can then pass to the...
connecting signals and slots with different relations
c++,qt,connect,signals-slots
You need to create new slot for that purpose. But in C++ 11 and Qt 5 style you can use labmdas! It is very comfortable for such short functions. In your case: connect(ui->horizontalSlider, &QSlider::sliderMoved, this, [this](int x) { this->ui->progressBar->setValue(x / 2); }); ...
Must compile Opencv with Mingw in order to use in QT under Winodws?
qt,opencv,mingw
You can compile it with Visual Studio as well. The opencv includepaths already have the opencv2 part of it. So the correct includepath would only be: C:opencv2.4.11opencvbuildinclude ...
How can I wrap text in QGraphicsItem?
qt,text,word-wrap,qgraphicsitem
You did not specify Qt version but try: void QGraphicsTextItem::setTextWidth(qreal width) Sets the preferred width for the item's text. If the actual text is wider than >the specified width then it will be broken into multiple lines. If width is set to -1 then the text will not be broken...
How to set User Agent in QtWebEngine QML application
qt,qml,qt5,user-agent,qtwebengine
I'm interested in using QtWebEngine too. And I can suggest you use QtWebEngine developers Trello. As you can see in Todo for 5.5 this is currently under development and may be done in 5.5....
QODBCResult::exec: Unable to execute statement: '[Microsoft][ODBC SQL Server Driver]COUNT field incorrect or syntax error
c++,sql-server,qt,tsql,odbc
The problem turned out to be the syntax, I changed it to query.prepare('{CALL add_syllabus_line (:teacher_name, :subject_name, :temporary_name, :type_name, :activity_name, :min_score, :max_score, :max_score_exists, :evaluation_by_exam)}'); QComboBox *combo = static_cast<QComboBox*>(table->cellWidget(i,0)); query.bindValue(':teacher_name', teacherName); query.bindValue(':subject_name', 'Физика'); query.bindValue(':temporary_name', ratingName); query.bindValue(':type_name', combo->currentText());...
How can I have an animated system tray icon in PyQt4?
python,qt,pyqt,pyqt4,system-tray
Maybe something like this. Create QMovie instance to be used by AnimatedSystemTrayIcon. Connect to the frameChanged signal of the movie and call setIcon on the QSystemTrayIcon. You need to convert the pixmap returned by QMovie.currentPixmap to a QIcon to pass to setIcon. Disclaimer, only tested on Linux. import sys from...
Pro file directive: copy target to folder at build step
qt,qt5
Create DestDir.pri in folder, where all of your projects located. Insert next code: isEmpty(DESTDIR) { CONFIG(debug, debug release) { DESTDIR=$$PWD/Build/Debug } CONFIG(release, debug release) { DESTDIR=$$PWD/Build/Release } } Include DestDir.pri to each pro file: include(../DestDir.pri) You can change DESTDIR variable to your path or set this variable via qmake command line utils...
How to avoid user to click outside popup Dialog window using Qt and Python?
qt,user-interface,python-3.x,dialog,qt-creator
use setModal() like so; dialog.setModal(1); Or; dialog.setModal(true); ...
Repeat state on mouse click QML
qt,qml,qtquick2
States are a way to represent different property configurations for a given Item. Each State has its unique set of values for the properties defined inside the specific Item. Transitions are a way to add animations to an Item when the current State changes to another State. They can be...
Qstring error. Saving from Textpool to string
c++,qt,qstring
http://doc.qt.io/qt-4.8/qlineedit.html#text-prop textChanged is a signal that you can send when the text changes Use QString text() const instead Another useful method: modified : bool to check if the text was modified by the user Update to answer additional comment questions: It is best to declare all variables as private. Add...
How to differentiate a QNetworkReply is aborted or not?
c++,qt,networking
If aborted, QNetworkReply::error() should return QNetworkReply::OperationCanceledError, which means: the operation was canceled via calls to abort() or close() before it was finished. ...
Context Pointer Lost in FSEventStreamCreate Callback (c++)
c++,osx,qt,fsevents,file-watcher
The problem was unrelated to this code. The pointer works fine but his object was lost.
Using QSimpleXmlNodeModel and QTreeView
c++,qt
There is an example delivered with Qt. Take a look at xmlpatterns/filetree example. It is not that easy as with some other models. You have to implement these abstract methods: QUrl QAbstractXmlNodeModel::documentUri(const QXmlNodeModelIndex &) const QXmlNodeModelIndex::NodeKind QAbstractXmlNodeModel::kind(const QXmlNodeModelIndex &) const QXmlNodeModelIndex::DocumentOrder QAbstractXmlNodeModel::compareOrder(const QXmlNodeModelIndex &,const QXmlNodeModelIndex &) const QXmlNodeModelIndex QAbstractXmlNodeModel::root(const...
How to align GUI elements like this? Qt, C++
c++,qt
Here is the most direct, but hardcoded way. #include 'widget.h' #include <QLabel> #include <QFont> Widget::Widget(QWidget *parent) : QWidget(parent) { QSize frameSize = this->frameGeometry().size() - this->geometry().size(); this->resize(frameSize + QSize(250, 125)); QLabel * label = new QLabel(this);// parenting instead of layouts label->resize(130, 32); label->move(60, 40); QFont f = label->font(); f.setPointSize(16); label->setFont(f); label->setText('Sample');...
Copy text and placeholders, variables to the clipboard
c++,qt,clipboard
You're not using the function setText correctly. The canonical prototype is text(QString & subtype, Mode mode = Clipboard) const from the documentation. What you want to do is assemble your QString ahead of time and then use that to populate the clipboard. QString message = QString('Just a test text. And...
QEvent ownership
c++,qt,memory-management
event = &stackevent; //valid ?? Usually that's not safe, but in this case it's valid, because the function notify won't return, untill the event is handled (or not) by someone (it means that stackevent will be 'alive' during this operation). delete heapevent; //valid? or lost ownership? Yap, that's valid...
QT-FTP Upload Error
c++,qt,ftp,qnetworkreply
I can't get, why do you use QNetwork instead awesome QFtp module, that provides all necessary for work with ftp? QFtp *ftp = new QFtp(parent); ftp->connectToHost('f13-preview.125mb.com'); ftp->login('1896230', 'mypassword'); and then use QFtp::put. That's all you need....
Is there a way to prevent Qt slider dragging beyond a value?
qt,qslider
Use this class and just set setRestrictValue() that is the minimum value that user can drag the slider slider.h #ifndef SLIDER_H #define SLIDER_H #include <QSlider> class Slider : public QSlider { Q_OBJECT public: Slider(QWidget * parent = 0); ~Slider(); void setRestrictValue(int value); private slots: void restrictMove(int index); private: int m_restrictValue;...
Signals and slots were one of the distinguishing features that made Qt an exciting and innovative tool back in time. But sometimes you can teach new tricks to an old dog, and QObjects gained a new way to connect between signals and slots in Qt5, plus some extra features to connect to other functions which are not slots. Let’s review how to get the most of that feature. This assumes you are already moderately familiar with signals and slots.
One simple thought about the basics
I am not going to bore you with repeating basic knowledge you already have, but I want you to look at signals and slots from a certain angle, so it will be easier to understand the design of the feature I will cover next. What’s the purpose of signals and slots? It’s a way in which “one object” makes sure that when “something happened”, then “other object” “reacts to something happened”. As simple as that. That can be expressed in pseudocode like this:
Notice that the four phrases that are into quotes in the previous paragraph are the four arguments of the function call in the pseudocode. Notice also that one typical way to write the connect statement is aligning the arguments like this, because then the first column (first and third arguments) are object instances that answer “where?” and the second column (second and fourth arguments) are functions that answer “what?”.
In C++ instead of pseudocode, and using real life objects and classes, this would look like this in Qt4 or earlier:
Qt Qml Signal Slot Example
That could be a typical statement from a “Hello World” tutorial, where a button is created and shown, and when it’s pressed the whole window closes and the application terminates.
Now to the main point that I want you to notice here. This has a very subtle advantage over a typical mechanism used in standard C or C++ 11 like callbacks with function pointers and lambda functions wrapped in std::function, and is subtle only because is so nice we often forget about it when we have used signals and slots for a while. If the sender object is destroyed, it obviously can not emit any signal because it is a member function of its class. But for the sender to call the receiver, it needs a pointer to it, and you as a user, don’t need to worry at all about the receiver being destroyed and becoming invalid (that is done automatically by the library), so you very rarely need to call QObject::disconnect.
So signals and slots are very safe by default, and in an automatic way.
The new versus the old way to use connect
The previous example shows one way that works across old versions of Qt published so far (Qt 1 to 5). Recently a blog post about porting a tutorial application from Qt 1 to Qt 5.11 has been published, and no porting was needed at all for signals, slots, or the connections! That doesn’t mean the feature is perfect, since a new way to make connections was added, keeping all the previous functionality.
The main problem with the example above is that (as you probably knew, or guessed from being all uppercase) is that SIGNAL and SLOT are macros, and what those macros do is convert to a string the argument passed. This is a problem because any typo in what gets passed to those means that the call to connect would fail and return false. So since Qt 5.0, a new overload to QObject::connect exists, and supports passing as second and fourth arguments a function pointer to specify which member function should be called. Ported to the new syntax, the above example is:
Now any typo in the name will produce a compile time error. If you misspelled “click” with “clik” in the first example, that would only fail printing a warning in the console when that function gets called. If you did that in some dialog of an application you would have to navigate to that dialog to confirm that it worked! And it would be even more annoying if you were connecting to some error handling, and is not that easy to trigger said error. But if you did the same typo in the last example, it would be a compile time error, which is clearly much better.
This example is usually said to be using the “new syntax”, and the previous example the “old syntax”. Just remember that the old is still valid, but the new is preferred in most situations.
Since this is an exciting new feature added to a new major version, which has received some extra polishing during the minor releases, many blog posts from other members of the Qt community have been published about it (for example covering implementation details or the issues that could arise when there are arguments involved). I won’t cover those topics again, and instead I will focus on the details that in my experience would be most beneficial for people to read on.
No need to declare members as slots anymore (or almost)
The new syntax allows to call not just a member function declared as slot in the header with public slots: (or with protected or private instead of public), but any kind of function (more on that in the next section). There is still one use case where you would want to declare functions as slots, and that is if you want to make that function usable by any feature that happens at run time. That could be QML, for example.
Connecting to anything callable
Now we can connect to any “callable”, which could be a free standing function, a lambda function or a member function of an object that doesn’t derive from QObject. That looks in code like the following:
But wait, where is that nice symmetry with 2 rows and two columns now?
When you connect to a lambda, there is a receiver object, the lambda itself, but there is no signature to specify since it’s the function call operator (the same would happen to a function object or “functor”, by the way). And when there is a free standing function there is a signature, but there is no instance, so the third and the fourth arguments of the first two calls are somewhat merged. Note that the arguments are still checked at compile time: the signal has no arguments, and the lambda has no arguments either. Both sender and receiver are in agreement.
The example using std::bind requires a bit more explanation if you are not familiar with it. In this case we have the two objects and the two function pointers, which is to be expected for what is wanted. We don’t often think about it like this, but we always need a pointer to call a member function (unless it is static). When it is not used, it is because this is implicit, and this->call() can be shortened to call(). So what std::bind does here is create a callable object that glues together the particular instance that we want with one member function. We could do the same with a lambda:
Note that std::bind is actually much more powerful, and can be very useful when the number of arguments differ. But we will leave that topic to another article.
One common use of the above pattern with std::bind is when you have a class implemented through a data pointer (private implementation or pimpl idiom). If you need a button or a timer to call a member function of the private class that is not going to be a QObject, you can write something like this:
Recovering symmetry, safety and convenience
With the previous examples that nice balance of the four arguments is gone. But we are missing something more important.
What would happen if the lambda of the previous examples would use an invalid pointer? In the very first C++ example we showed a button wanting to close the application. Imagine that the button required to close a dialog, or stop some network request, etc. If the object is destroyed because said dialog is already closed or the request finished long ago, we want to manage that automatically so we don’t use an invalid pointer.
An example. For some reason you show some widget and you need to do some last minute update after it has been shown. It needs to happen soon but not immediately, so you use a timer with a short timeout. And you write
That works, but has a subtle problem. It could be that the widget gets shown and immediately closed. The timer under the scenes doesn’t know that, and it will happily call you, and crash the application. If you made the timer connect to a slot of the widget, that won’t happen: as soon as the dialog goes away, the connection gets broken.
Since Qt 5.2 we can have the best of both worlds, and recover that nice warm feeling of having a well balanced connect statement with two objects and two functions. 🙂
In that Qt version an additional overload was added to QObject::connect, and now there is the possibility to pass as third argument a so called “context object”, and as fourth argument the same variety of callables shown previously. Then the context object serves the purpose of automatically breaking the connection when the context is destroyed. That warranties the problem mentioned is now gone. You can easily handle that there are no longer invalid captures on a lambda.
The previous example is almost as the previous:
Now it is as if the lambda were a slot in your class, because to the timer, the context of the connection is the same.
The only requirement is that said context object has to be a QObject. This is not usually a problem, since you can create and ad-hoc QObject instance and even do simple but useful tricks with it. For example, say that you want to run a lambda only on the first click:
Qt Qml C++ Signal Slot
This will delete the ad-hoc QObject guard on the first invocation, and the connection will be automatically broken. The object also has the button as a parent, so it won’t be leaked if the button is never clicked and goes away (it will be deleted as well). You can use any QObject as context object, but the most common case will be to shut down timers, processes, requests, or anything related to what your user interface is doing when some dialog, window or panel closes.
Tip: There are utility classes in Qt to handle the lifetime of QObjects automatically, like QScopedPointer and QObjectCleanupHandler. If you have some part of the application using Qt classes but no UI tightly related to that, you can surely find a way to leverage those as members of a class not based on QObject. It is often stated as a criticism to Qt, that you can’t put QObjects in containers or smart pointers. Often the alternatives do exist and can be as good, if not better (but admittedly this is a matter of taste).
Bonus point: thread safety by thread affinity
The above section is the main goal of this article. The context object can save you crashes, and having to manually disconnect. But there is one additional important use of it: making the signal be delivered in the thread that you prefer, so you can save from tedious and error prone locking.
Again, there is one killer feature of signals and slots that we often ignore because it happens automatically. When one QObject instance is the receiver of a signal, its thread affinity is checked, and by default the signal is delivered directly as a function call when is the same thread affinity of the sender. But if the thread affinity differs, it will be delivered posting an event to the object. The internals of Qt will convert that event to a function call that will happen in the next run of the event loop of the receiver, so it will be in the “normal” thread for that object, and you often can forget about locks entirely. The locks are inside Qt, because QCoreApplication::postEvent (the function used to add the event to the queue) is thread-safe. In case of need, you can force a direct call from different threads, or a queued call from the same thread. Check the fifth argument in the QObject::connect documentation (it’s an argument which defaults to Qt::AutoConection).
Let’s see it in a very typical example.
This shows a class that derives from QRunnable to reimplement the run() function, and that derives from QObject to provide the finished() signal. An instance is created after the user activates a button, and then we show some progress bar and run the task. But we want to notify the user when the task is done (show some message, hide some progress bar, etc.).
In the above example, the third argument (context object) might be forgotten, and the code will compile and run, but it would be a serious bug. It would mean that you would attempt to call into the UI thread from the thread where the task was run (which is a helper thread pool, not the UI thread). This is wrong, and in some cases Qt will nicely warn you that you are using some function from the wrong thread, but if you are not lucky, you will have a mysterious crash.
Wrap up
Hopefully now you’ve understood why that odd point was made in the introduction section. You don’t have to agree that it is aesthetically pleasing to write the arguments to connect in two rows and two columns, but if you understood the importance of using a context object as a rule of thumb, you probably will find your preferred way to remember if that third argument is needed when you write (or review other’s) code using connect.