Qt has two kinds of lists, tables, and trees. One kind uses a model/view setup which gives a great separation between data and presentation. The other one is item based, meaning your data is stored in the items, just like the checked value is stored inside the checkbox.
Effective debugging in embedded Linux requires a full-stack approach and the right tools. This post covers key techniques—from hardware abstraction and static analysis to profiling and logging—to help you build more reliable systems.
This YouTube short summarizes changes needed to have a Qt Quick app work with both Qt 5 and Qt 6. It primarily focuses on required changes to QML and CMake files, but it also mentions other aspects of porting C++ and shaders that are discussed more in depth in other videos.
This post explores implementing drag-and-drop onto existing items in Qt, such as moving emails between folders. It covers both Model/View and Item Widget approaches, detailing key setup steps and improvements made to Qt along the way.
Are you curious about the transition from a C++ code base to Rust? This video explores the experiences of the @hulks_tuhh, a RoboCup team from Hamburg, that successfully made the switch. Discover their initial motivations for using Rust, the valuable lessons learned throughout the process, and how the team is currently benefitting from it. Listen to their story and learn why KDAB became one of their sponsors.
Not sure which technology stack and UI library to choose for your next embedded project? Olivier Goffart from Slint and Miłosz Kosobucki from KDAB discuss why C++ and Slint may be a good choice. Learn about the pros and cons of these technologies to make a more informed decision.
Choosing the right programming language for your embedded Linux device is crucial. Learn the nuances of C++, Rust, and Dart to make an informed decision.
Shipping your app with all dependencies is hard. One way to solve this, is to use Docker on Embedded to combine all dependencies into a single update. In this video, Christoph presents Torizon, one Docker-based solution to handle images and updates on Embedded.
Building an embedded device is a challenge in itself, but bringing it to market means even more work. In this short 'Insights' video, Christoph describes what KDAB did for their customer Kistler, who builds some of the most precise pressure-measurement devices available, to bring a very mobile, handheld device from prototype to market.
In this follow-up to our drag-and-drop guide, we explore how to move items between views in Qt’s model/view framework. Learn how to set up both drag and drop sides, handle MIME data, and implement key model methods. Whether you're working with model/view separation or with item widgets, this post provides practical examples to help you customize UI interactions effectively.
In this video, Christoph explains how to configure, create and schedule Over-The-Air Update Builds in the Yocto buildsystem.
This is the fourth and final video in the embedded Linux series, which goes over development environment considerations.
With NLnet support, KDE Plasma’s Wayland session now offers improved accessibility and creative tool support. Enhancements include better sticky keys feedback, customizable tablet areas, pressure curve adjustments, and configurable stylus buttons. These updates make Wayland more inclusive, reinforcing KDE’s commitment to accessibility.
Meet KDAB at Embedded World and explore demos featuring Qt, C++, 3D, Slint, Rust, and Flutter, including the HULKs Robot with the first SPL Robotics Framework built with Rust.
This third video goes over the choices you have for the entire software stack from the OS to the application and gives you things to consider at every step.
Key architectural choices - monolithic vs. microservices - impact scalability and complexity. Planning for multi-user support early prevents costly modifications, while containers enhance consistency and security in deployment. Strong security practices, such as minimizing root access and securing OS vulnerabilities, are essential for resilience. Thoughtful planning ensures a scalable, secure, and maintainable embedded system.
This second video in the series of four, covers the numerous planning considerations that go into choosing your hardware to help you expediate your development process.
This blog post is the first in a series on implementing drag-and-drop in the Qt model/view framework. It covers how to reorder items within a single view, whether you're using QListView, QTableView, or QTreeView with a custom model, or QListWidget, QTableWidget, or QTreeWidget with items. The post includes code examples, checklists, and insights into improvements made in Qt 6.8 for smoother drag-and-drop functionality.
This is the first video in a series based on a whitepaper about designing your first embedded device; it covers the beginning and ending of the product development process.
The "Locator" in Qt Creator offers an extensive set of commands that make programming easier. In this video we show a subset of its features, hidden behind the Ctrl+K shortcut.
