Presented by Vasily Pereverzev
This session will highlight the main pitfalls faced when migrating a classic QWidget-based desktop application and their solutions.
Using the example of our experience in transitioning the MuseScore software, I’ll describe the challenges faced when transforming a design from the 2000s to QtQuick. We’ll also discuss effective strategies for migrating from QWidgets on QML, and cover limitations faced with mixing both systems in a single app and approaches to overcome or even avoid them entirely.
My name is Vasily Pereverzev, I’m the Engineering Team-Lead for the MuseScore composition software. Previously, I lead a team of more than 15 people focused on developing mobile applications and experiences using the Qt platform. For the past 6 years, I have been completely absorbed in working with Qt, becoming an especially BIG fan of QML.
Presented by Marco Martin
Kirigami is a framework built on top of QML and QtControls2 that aim to make easier for applications to implement a modern design language for both desktop and mobile systems, providing features that base QML and QtQuickControls don’t have.
Within the KDE project our main goal, front and center is and always was providing a top notch desktop experience, even tough recently we are interested in mobile as well.
QWidgets is a very complete desktop UI framework, but unfortunately it’s quite behind the times, being mostly based on software rendering and with and also outdated looking look and feel of its components. On the other hand, QML is a fully-featured modern graphics engine for 2D GUI perfect for mobile and embedded user interfaces, but still somewhat lacks in components and features that traditional desktop productivity applications need.
Kirigami aims to make the life easier for the developer to build good looking QML-based desktop (and not only) applications.
The talk will go over the architecture of Kirigami, the challenges in QML that we worked around, those challenges that are still unsolved problems.
Marco Martin started contributing in KDE in 2008 and has been an active contributor ever since. currently, he is maintainer of the Kirigami framework and co maintainer of the KDE Plasma Desktop.
He currently works for Blue Systems currently serving as CTO.
Presented by Prashanth Udupa
Scrite is a free and open-source screenplay writing app for Linux, macOS and Windows Desktops. Insights and Learnings I have been developing desktop apps using Qt since 2001. As a long time QtWidgets user, I had discarded QML as a viable desktop UI development tool when it was first announced around 2011. However, having used QML even within desktop apps over the past few years – I am convinced that QML can be used for building large & beautiful desktop apps – even productivity apps! I have discovered a handful of design patterns that one could leverage to build beautiful desktop apps using QML. In my talk I wish to share some of these insights, specifically that – We have to breakdown everything into a model-view problem – We have to have mastery over the meta-object system – We have to get comfortable with creating new QML Attached Properties & Singletons – We need to pay attention to the fact that UI and Business Logic are in separate threads – We can use ScrollView+Flickable+Item+Repeater as a replacement for QGraphicsView – We may need to buckle up and subclass from QQuickItem occasionally – Using Loaders can help keep memory consumption in check – It pays to spend some time to learn using GammaRay. It can help bring you back from hell when things go wrong! I am not writing this simply because I am submitting a talk proposal to an event hosted by KDAB. – Lastly, you are likely to become a better software architect of QtWidgets apps.
I am a software developer from Bengaluru India. My love for Qt goes back to 2001, when I began using it for a college project. I started a product development & consulting company in 2005 where my team used Qt extensively. I am author of opensource projects like VTK Designer, GCF and now Scrite. I regularly consult large multinational companies on leveraging Qt for building large desktop products. I also regularly conduct training programs on Qt for companies in India.
Presented by Sérgio Martins
KDDockWidgets was born from my need to preserve sanity after having worked on projects that needed extensive QDockWidget customization. Ashamed from abusing
event filters to hijack mouse events, tired of using Qt private API to implement hacks that would break after a Qt version bump, I’ve decided to write a new framework
that incorporates all our learnings from hacking QDockWidget.
In this presentation I’ll show you which features are must-haves in modern docking systems, what sets KDDW apart from QDockWidget not only in terms of functionalities, but in customization capabilities and code stability too.
Finally, we’ll put KDDW’s extensibility claims to the test and talk about the QtQuick/QML support.
Sérgio has been with KDAB for 10 years, he loves performance profiling, debugging, static-analysis and tooling. You won’t see him writing nice looking GUIs or 3D. He’d rather enjoy tackling an hard problem, frequently embracing the pain of bugs nobody wants, such as HDPI, fonts, QDockWidget and even working on Windows when needed.
Sérgio is also an opensource entushiast, a KDE developer since 2009, having maintained
KOrganizer for several years and author of Clazy, the static-analyzer for Qt.
Presented by Romain Pokrzywka
Most desktop applications are still primarily designed for mouse and keyboard interactions. But with the increasing popularity of 2-in-1s and other form factors with touchscreens and inking, adding touch and pen input handling to an application can offer valuable new capabilities with little effort. In this talk, we will first give an overview of the APIs provided by Qt to handle touch and pen input within an existing QtWidget or QML application running on Windows or Linux. We will then present various strategies to complement a mouse-based UI with touch and pen capabilities. Finally, we will get a sneak peek at some changes and improvements coming to the input stack in Qt6.
Romain Pokrzywka is the architect for Bluescape’s native application. He has been developing with Qt for over 15 years on projects spanning desktop, embedded and mobile platforms, and he has given several talks at past Qt conferences. He’s also a long term contributor to the Qt Project. He has a passion for innovative user interfaces and elegant software architectures to create unique user experiences. A native from France and former Silicon Valley resident,
he now lives in Austin, in the heart of Texas.
Presented by Frerich Raabe
As Qt-based applications grow in complexity, so do their graphical user interfaces (GUIs). Manually testing every piece of functionality is tedious at best. Hence, many software projects consider automating at least some of their GUI testing efforts – and rightfully so.
In this presentation, the test automation tool Squish will be used to implement a proven and capable approach to GUI test automation. In particular, attendees will learn how applying the principles of Behavior-Driven Development (BDD) to test development can be of great aid with developing and structuring test code.
Software engineer working at froglogic since 2005, having spent most of the time since on developing the GUI test automation tool Squish. When he’s not currently building awesome Lego creations with his son, he can typically be found playing video games.
Presented by Craig Loewen and Avri Parker
The Windows Subsystem for Linux (WSL) is a tool that allows you to run your favorite command line tools, utilities and applications directly inside of Windows. Come join this session to learn how to have a fully featured Linux development environment on your Windows machine using WSL and other tools like VS Code Remote.
Craig is a Program Manager working at Microsoft on the Windows Subsystem for Linux (WSL). He joined Microsoft in 2018 to help empower users to run their favorite Linux command line tools, utilities and workflows all directly on a Windows machine, following graduating from the University of Waterloo with a degree in mechatronics engineering.
Avri is a Program Manager at Microsoft driving Windows performance improvements and enterprise features for the Windows Subsystem for Linux (WSL). She joined Microsoft in 2019 after graduating from the University of Southern California with a degree in computer science and business administration. Her goals are to improve the performance of developer workflows on Windows and to make WSL ready for enterprise consumption.
Presented by Franck Arrecot
Building complex user interfaces with widgets have been the bread and butter of Qt’s ecosystem for the past decades. While it largely involves a well-known set of tools and practices, achieving complex layouts requires experience to avoid common pitfalls which might make the code harder to maintain and impact runtime performance. For example, we will show that reducing the number of widgets and layouts in use can improve the readability of the code and the performance of the application. We will also show how views can be used to achieve layout of multiple widgets but also how this can make styling and layout more complex, such as achieving proper alignment of multiple groups of widgets. We will also survey a number of small tips and tricks that can be utilized to solve simple UI behavior. Finally, when investigating how some layout operations affect performance, will investigate potential hotspots and available tools.
After obtaining his Master’s degree in computer science, Philippe has been working as a software engineer at Allegorithmic since 2016. He is now an Adobe employee and works on Substance Painter. Philippe is particularly interested in C++ development and UI/UX issues.
Software engineer at KDAB, Franck has actively developed with Qt since 2011 when he started contributing to open source projects. He has been an active KDE contributor to Zanshin: KDE task management software and more recently to the Qt3D module. He holds a Masters’s degree in Computer Science.
Presented by Jean-Baptiste Kempf
VLC is using Qt as its main GUI library since 2009 when it moved to Qt4 and QtWidgets.
Tens years later, we’re changing heavily the interface of VLC, and we’re moving to Qt5 and Qml as our main engine for the interface. The new interface, planned for VLC 4.0 will change the way people interact with VLC.
This talk will trace back our history about VLC and Qt and will explain what we will do on the new interface.
Jean-Baptiste Kempf is the president of the VideoLAN non-profit organization and one of the lead developers of the open source VLC media player. Jean-Baptiste is a 37-year old French engineer and has been part of the VideoLAN community since 2005. Since then, he has worked on or lead most VideoLAN related projects, including VLC for desktop, the relicensing of libVLC, the ports to mobile operating systems, and various multimedia libraries like libdvdcss or libbluray.
He also created the legal entity of VideoLAN, a French non-profit organization, in 2008.
Jean-Baptiste has also been working in various video-related startups, and founded VideoLabs, a company focusing on open source multimedia technologies.
Presented by Nyall Dawson
The QGIS desktop mapping application is a mature, open-source desktop application that is used by millions of users and professional organisations worldwide — and it’s all built on the Qt framework! Building the application on Qt has allowed us to become one of the most well respected and full-featured tools for professional cartographic design and analysis of spatial data, thanks in a huge part to the power and ease-of-use of the Qt libraries. During this talk, I’ll be exploring exactly how QGIS uses Qt, where we think that Qt’s strengths and weaknesses lie, and some of the advice and Qt development tips that I’ve learned during my involvement with the project.
Nyall has been a developer with the QGIS project since 2013. During this time he has contributed over 5000 additions to the project, and today is one of the most active developers on the project. Nyall’s contributions cover a wide range of areas – from improvements to the map rendering and symbology engines, enhancements to labeling and print layout functionality, right through to optimisations of the underlying spatial processing algorithms utilised by QGIS. Nyall is the proprietor of North Road Consulting, an Australian based spatial development consultancy which predominantly utilises international co-funding and crowd-funding campaigns to finance development into open source GIS applications.
Presented by Nicholas Medeiros
Instituting aggressive testing can help to ensure product quality, but a blind “test more” strategy can, at best, result in redundancy, and at worst, result in missed critical code areas, which can have cascading consequential effects — some life-threatening
— if not managed.
A structured, “test smarter” approach, using code coverage analysis as a basis, is more appropriate. With a code coverage tool, we can determine how much of our application’s source code has been hit by tests, which additional tests need to be written, how the test coverage has changed over time, and much more.
During this talk, we’ll introduce froglogic’s cross-platform, cross-compiler toolchain “Coco” for code coverage analysis of your Qt- or QML-based (or any C/C++/C#) application. We’ll explore how you can use Coco to enhance your desktop Qt application’s quality and improve your testing efficiency. We’ll also cover our unique support for garnering coverage data from automated GUI testing methods, in a streamlined, automatic manner. Lastly, we’ll focus on safety-critical software applications, for which code coverage takes special meaning before bringing a product to market.
Nick joined froglogic Marketing in 2018, following graduate study in computational mechanics and various Application Engineering roles within the software sector. When he’s not blogging for froglogic, he enjoys testing vegan recipes, reading poetry, and modding his Subaru.
Presented by Shantanu Tushar
Developing desktop applications in QML can be very effective – your toolbox will range from bindings to things like state transitions. Programming constructs aside, Qt Creator offers another helpful tool for developing applications in QML – the Qt Quick Designer. Similar to Qt Designer in the widgets world, it allows you to drag’n’drop UI elements and set properties. However, it can do more! You can setup bindings, preview states and even define animations using keyframes. This can be useful if you need close collaboration with your design team. Apart from quick iterations and ability to preview your UI, you can even pair with your team’s designer and work on the UI together. This talk will cover effective ways of using Qt Quick Designer and also common pitfalls and limitations.
Shantanu has been developing with Qt/C++ since 2009 when he started contributing to various KDE projects as a student. He works as a Software Engineer at KDAB and in the past has been the driving force behind the SoStronk esports desktop application. With a focus on usability, Shantanu loves using QML/Qt Quick to create elegant and enjoyable user interfaces. When not working on UI, you will find him tinkering with DIY electronics and home automation.