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.

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.

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.

Mozilla is the maker of the famous Firefox web browser and the birthplace of the likes of Rust and Servo (read more about Embedding the Servo Web Engine in Qt). Firefox is a huge, multi-platform, multi-language project with 21 million lines of code back in 2020, according to their own blog post. Navigating in projects […]

In a recent email, KDABian Leon Matthes highlighted some of his go-to command line tools for everyday use on Unix. His recommendations sparked a lively exchange among our colleagues, each sharing their own favorite utilities. Many of these tools offer efficient alternatives to standard Unix programs, speeding up the workflow or otherwise enriching the development […]

The goal When building C++ code with CMake, it is very common to want to set some pre-processor defines in the CMake code. For instance, we might want to set the project's version number in a single place, in CMake code like this: This sets the CMake variable PROJECT_VERSION to 1.5, which we can then […]

In recent years, a lot has been happening to improve performance, maintainability and tooling of QML. Some of those improvements can only take full effect when your code follows modern best practices. Here are 10 things you can do in order to modernize your QML code and take full advantage of QML's capabilities. 1. Use […]

Recap In Part 1, we covered PCM audio and superimposing waveforms, and developed an algorithm to combine an arbitrary number of audio streams into one. Now we need to use these ideas to finish a full implementation using Qt Multimedia. Using Qt Multimedia for Audio Device Access So what do we need? Well, we want […]

In C++20, the standard library introduced new synchronization primitives: std::latch and std::barrier. These are the utilities designed to coordinate between concurrent threads. What is a synchronization primitive? In concurrent programming, synchronization primitives are the fundamental tools that help in managing the coordination, execution order, and data safety of multiple threads or processes that run concurrently. […]

Motivation When using Qt Multimedia to play audio files, it’s common to use QMediaPlayer, as it supports a larger variety of formats than QSound and QSoundEffect. Consider a Qt application with several audio sources; for example, different notification sounds that may play simultaneously. We want to avoid cutting notification sounds off when a new one […]

Creating applications for cross-platform compatibility is a modern best practice. It increases deployment flexibility and allows applications to reach a wider audience. However, doing it properly can involve some trial and error. At KDAB, we’ve built many multiplatform desktop applications. Here, we’ve compiled a few insights from that process to help you build better software. […]

CppCon is the annual, week-long face-to-face gathering for the entire C++ community – the biggest C++ event in the world. This year, CppCon takes place in Aurora, Colorado, near the Denver airport. Including multiple diverse tracks, the conference will appeal to anyone from C++ novices to experts. At CppCon, you can expect interesting talks and […]

In the previous posts of this series (if you've missed them: parts 1, 2, 3, and 4), we have learned about relocation and trivial relocation. We have explored what relocation means, what trivial relocation means, and how it can be used to optimize the implementation of certain data structures, such as the reallocation of a […]

In our earlier blog, The Smarter Way to Rust, we discuss why a blend of C++ and Rust is sometimes the best solution to building robust applications. But when you’re merging these two languages, it’s critical to keep in mind that the transition from C++ to Rust isn’t about syntax, it’s about philosophy. Adapting to […]

Motivation Let’s say we’re working on a QML project that involves a TextEdit. There’s some text in it: here is some text We want to select part of this text and hit ctrl+B to make it bold: here is some text In Qt Widgets, this is trivial, but not so much in QML – we […]

If you’ve been following our blog, you’re likely aware of Rust’s growing presence in embedded systems. While Rust excels in safety-by-design, it’s also common to find it integrated with C++. This strategic approach leverages the strengths of both languages, including extensive C++ capabilities honed over the years in complex embedded systems. Let’s delve into some […]

Qt Test is a framework designed for unit testing applications and libraries built with Qt. It provides all the standard features commonly found in unit testing frameworks, making it easier to write unit tests for Qt-based projects. We're happy to introduce the QtTest Runner - a Visual Studio Code extension for running Qt Tests via […]

Since we first announced it last year, our Vulkan wrapper KDGpu has been busy evolving to meet customer needs and our own. Our last post announced the public release of v0.1.0, and version 0.5.0 is available today. It's never been easier to interact with modern graphics technologies, enabling you to focus on the big picture […]

In the last post of this series we learned that: erasing elements from the middle of a vector can be implemented, in general, via a series of move assignments, move constructions, swaps, destructions for types with value semantics, the exact strategy does not really matter for types with write-through reference semantics, the strategy matters, because […]

In the last post of this series we started exploring how to erase an element from the middle of a vector. We discussed that in principle there are several different possible ways to implement erase().For instance, a vector could move-assign over the elements to be erased: Alternatively, a vector could use rotations or some other […]