Developing a QML Keypad with TDD
Although Qt comes with a unit-test framework QuickTest for QML code, hardly any QML GUIs are unit-tested, let alone developed with TDD (test-driven development). One… Read More »Developing a QML Keypad with TDD
Although Qt comes with a unit-test framework QuickTest for QML code, hardly any QML GUIs are unit-tested, let alone developed with TDD (test-driven development). One… Read More »Developing a QML Keypad with TDD
Two years ago, I spent three days to figure out why the driver terminal of a sugar beet harvester crashed (see my original post). The crash happened after going through the same six-step interaction at least four times. The reason was that the C++ code accessed an object that the QML engine had already deleted. For the last two years, I have heard a lot of good things about address sanitizers. When I threw address sanitizers at the old problem, they identified the problem right away. Recently, address sanitizers helped me to locate and fix some strange crashes on a legacy application. Sanitizers will be part of my debugging toolbox from now on.
Read More »QML Engine Deletes C++ Objects Still In Use – Revisited with Address SanitizersOverdraw happens when one QML item fully eclipses another QML item. The QML renderer always draws both items, although there is no need to draw the eclipsed item. You must help out the renderer by explicitly setting visible: false
on the eclipsed item.
On embedded systems, heavy overdraw makes animations or flicking jerky. In the worst case, it freezes your HMI. Fortunately, the Qt experts at KDAB developed a tool, GammaRay, which makes detecting overdraw a piece of cake. I’ll show you how to build GammaRay, how to detect overdraw in the home screen of a harvester HMI, and how to fix the overdraw.
Read More »Detecting Overdraw in QML HMIs with GammaRayI know that this is pretty old news. Unfortunately, it is not very well known. I have been asked half a dozen times over the last two months, whether the QML software renderer – officially known as the Qt Quick 2D renderer – is available under LGPLv3. Nobody belives me, when I answer with a firm “Yes!”.
Read More »Qt Quick 2D Renderer: Under LGPLv3 since Qt 5.8Correction: In the original post, I stated that ownership is transferred from C++ to QML by READ functions of Q_PROPERTYs. This is wrong. Ownership is only transferred by Q_INVOKABLE functions and slots, which return a QObject pointer. I corrected my post and my code example. Now, the simple code example crashes as desired. Many thanks to Richard and Simon for pointing out my mistake.
I recently spent three days on a customer project to figure out why my QML application crashed with a segmentation fault. The crash happened after a long sequence of interactions, which was hard to reproduce. I finally managed to reproduce the crash reliably after going through the same six-step interaction four times.
After many hours of debugging and scrutinising my code, I had an epiphany about the stack trace leading to the crash. The stack trace originated from deep inside the QML engine and ended in calling the destructor of a C++ object, which was still in use on the C++ side. The trace never touched any of the application’s C++ code in between.
So far, I had only asked myself the question: Where in my C++ code do I corrupt the memory? After my little epiphany, I changed my question: Why does the QML engine delete a C++ object still in use? What do I overlook in the interaction between QML and C++?
Read More »QML Engine Deletes C++ Objects Still In Use
My favourite new feature in Qt 5.10 is the inconspicuous function QmlEngine::retranslate()
. Finally, seven years after QML’s birth, there is a Qt way to change the language of your application at runtime. There is no need for workarounds any more (see How to do dynamic translation in QML for the standard workaround).
I wrote a simple application demonstrating the new feature. If we click the British (German) flag on the right-hand side, the language of the labels on the left-hand side is changed accordingly.
How does the dynamic language change work?
Read More »New in Qt 5.10: Dynamic Language Change in QML
We have defined a Qt property warningLevel
in the C++ class MainModel
:
Q_PROPERTY(WarningLevel::Enum warningLevel READ warningLevel WRITE setWarningLevel NOTIFY warningLevelChanged)
We want to use this property in QML. For example, we want to colour a rectangle according to the warningLevel
:
import com.embeddeduse.models 1.0 // ... property MainModel mainModel : MainModel {} Rectangle { color: toColor(mainModel.warningLevel) // ... } function toColor(level) { switch (level) { case WarningLevel.Error: return "red" case WarningLevel.Warning: return "orange" case WarningLevel.Info: return "green" case WarningLevel.Debug: return "purple" default: return "magenta" } }
Note how we access the C++ property mainModel.warningLevel
from QML to set the color
of the rectangle and how we use symbolic enum constants like WarningLevel.Info
in the function toColor()
.
It is similarly easy to use a list of the symbolic enum constants as the model of a Repeater
and to assign the warning level by the user to the property mainModel.warningLevel
in the onReleased
handler of a MouseArea
.
Repeater { model: [WarningLevel.Error, WarningLevel.Warning, WarningLevel.Info, WarningLevel.Debug] Rectangle { color: toColor(modelData) // ... MouseArea { anchors.fill: parent onReleased: mainModel.warningLevel = modelData } } }
I’ll show you in the rest of this post how to write your C++ code so that you can use a C++ property of enum type easily in QML.
Read More »Passing Enum Properties between C++ and QML
I am proud to announce that my talk Qt vs. Web – Total Cost of Ownership was accepted for Qt World Summit 2017. It is scheduled… Read More »Announcing My Talk “Qt vs. Web – Total Cost of Ownership” at Qt World Summit 2017
The Qt Company published a guest post “Qt QML v HTML5 – a practical comparison” and a whitepaper by the Austrian Qt consultancy Sequality. Sequality… Read More »More Reasons For Not Using Web