KDAB TV – Archive

An Unexpected C++ Journey - Daniel Vrátil (Can you use "Umlaut" in variable names in C++?)

About once a year, all of KDAB employees come together so we can get to know each other in a different way, and, among other things, introduce new members of the KDAB family, who are encouraged to give a ten-minute "newbie talk" on anything they are interested in. Last year Daniel Vrátil joined KDAB. We thought you'd enjoy his introductory talk.

63 2

Multithreading with Qt / qthread - Giuseppe D’Angelo

This talk introduces you to the fundamentals of threading in Qt / qthread. We will discuss how threads, QObjects and events interact together; how a thread affinity of a QObject has a play in signals and slots connections; and how you can leverage the modern C++11 threading capabilities in your Qt application. More info and slides at https://www.kdab.com/multithreading-with-qt/

178 11

Integrating OpenGL with Qt Quick 2 applications - Giuseppe D’Angelo

This talk will introduce you to various effective strategies of drawing raw OpenGL content inside a Qt Quick 2 scene. After a brief introduction to how the Qt Quick 2 renderer works, we will see the APIs in Qt 5.6 that allow us to integrate existing OpenGL code and QML. More info at https://www.kdab.com/integrating-opengl-with-qt-quick-2-applications/

104 5

Writing custom Qt Quick components using OpenGL - Kevin Funk

Qt Quick and QML provide an easy way to rapidly develop customized, reusable components entirely within QML. As these components grow in complexity, performance and maintainability often suffer, a drawback that is especially noticeable on low-powered embedded and mobile devices. In addition, some specialized components simply cannot be implemented by combining existing Qt Quick items in QML. For these cases, Qt Quick provides access to its underlying OpenGL scene graph via a C++ API. Components created this way are more closely aligned to the underlying scene graph architecture allowing improved performance and a cleaner implementation.

80 4

Qt 3D Basics - Kevin Ottens

Having 3D scenes in your application is becoming a clear trend and is likely to become even more important in the future with the growth of Virtual Reality and Augmented Reality. So far Qt was allowing you to integrate with Open GL fairly easily, but managing the rendering code itself was still a very challenging task. That's why Qt 5.7 will provide a new module named Qt 3D. In this talk we will cover the basics of its API. In particular, we will highlight how it eases the creation of 3D scenes, but we'll also point out that it is a full simulation engine and as such can do much more than 3D rendering. More info at https://www.kdab.com/qt-3d-basics/

13 3

Refactor Your OpenGL Legacy With Style - Kevin Ottens

Using OpenGL code with Qt is a long love story... long enough that there might be skeletons in the closet. Indeed, the OpenGL code of your Qt application could have been written before the modernization of the OpenGL API to exploit better GPUs. In this talk, we will walk through a technique to help refactor your old OpenGL code in the safest way possible and get it ready for the 21st century. More info at https://www.kdab.com/refactor-opengl-legacy-style/

6 0

All about Qt on Android - Bogdan Vatra

In this session we'll see real life examples of using JNI on Android. We'll start by checking the Qt 5.7 goodies which will make our lives easier, then we'll see simple examples that you'll need to use in almost any Qt on Android application, and we'll end up with an Android Service made with Qt. More info at https://www.kdab.com/all-about-qt-on-android/

31 0

Qt 3D and Physics Based Rendering - Sean Harmer

Physics Based Rendering (PBR) is the latest and greatest trend in real-time rendering yielding much more visually believable images than the traditional Phong or ad-hoc lighting models. The underlying concept is that the shaders should use physical principles in the encoded models - chief of which are conservation of energy and the Fresnel effect. More info at http://www.kdab.com/qt-3d-physics-based-rendering/

43 0

QtDD14 - Till Adam - Why Qt Matters In the Big Picture

Recorded at the Qt Developer Days in Berlin in 2014

10 0

QtDD14 -Analyzing Performance of QtQuick Applications - Thomas McGuire

Recorded at the Qt Developer Days in Berlin in 2014

11 0

QtDD14- Introducing Qt3D 2.0 (3D rendering & visualisation) - James Turner / Giuseppe D'Angelo

Recorded at the Qt Developer Days in Berlin in 2014

41 6

QtDD14 - QtWidgets and QtQuick Controls - A Comparison Kevin Krammer

Recorded at the Qt Developer Days in Berlin in 2014

23 1

QTDD14 - QtWebChannel - Bridging the Gap between HTML and Qt - Milian Wolff, KDAB

Recorded at the Qt Developer Days in Berlin in 2014

37 3

QtDD14 - David Faure - Additional Qt libraries outside of the Qt Project

Recorded at the Qt Developer Days in Berlin in 2014

5 4

QTDD14 - DIY moc - Dynamic Meta Objects - Volker Krause, KDAB

Recorded at the Qt Developer Days in Berlin in 2014

47 5

QTDD14 - Contributing to Qt -- hands on - Giuseppe D'Angelo, KDAB

Recorded at the Qt Developer Days in Berlin in 2014

4 0

QtDD14- From QtWidgets Legacy to QtQuick and beyond - Kevin Ottens

Recorded at the Qt Developer Days in Berlin in 2014

1 0

QtDD12 - OpenGL with Qt 5 - Dr. Sean Harmer

Recorded at the Qt Developer Days in Berlin in 2012.
Slides available at http://qtconference.kdab.com/node/25

Qt5 introduces better support for OpenGL from the QPA/Lighthouse abstraction, through a new set of OpenGL classes up to QtQuick 2 and Qt3D. OpenGL is also very often used for games and as the central content widget in desktop applications. With the advent of QtQuick 2 it is now easy to write entire user interfaces that harness the power of OpenGL.

This presentation will take you on a tour of Qt 5's support for OpenGL and show how to use it in various scenarios.

If time permits we will also take a sneak peak at some of the OpenGL related goodies coming in future Qt 5 releases.

Intended audience: Qt developers with an interest in OpenGL, Qt Contributors

170 6

QtDD12 - Modern Shader-based OpenGL Techniques - Dr. Sean Harmer

Recorded at the Qt Developer Days in Berlin in 2012.
Slides available at http://qtconference.kdab.com/node/25

Modern OpenGL abandons the old fixed-function pipeline in exchange for a programmable pipeline using shaders and buffer objects. This offers much more flexibility to developers and opens the door to a huge range of effects and techniques whilst at the same time making available huge performance improvements.

This presentation will teach you about the modern OpenGL pipeline and show how to create modern shader-based OpenGL applications with Qt 5. We will then demonstrate a selection of rendering techniques that go beyond the simple ADS-lighting model used in legacy OpenGL. Some examples that we will cover using OpenGL 3.x or 4.x:

Basic shader and buffer object usage - "hello triangle"
Simple phong lighting
Toon/cell shading
Ambient occlusion using texture mapping
Reflection and refraction with environment maps
Instanced geometry
Single-pass wire-frame rendering using Geometry Shaders
GPU based tessellation
Post-processing effects

Intended audience: Qt developers with an interest in OpenGL

82 5

QtDD13 - James Turner - Integrating QtQuick with 3D renderers

Recorded at the Qt Developer Days in Berlin in 2013.
Slides available at https://devdays.kdab.com/?page_id=225

Short Abstract:
QtQuick provides a modern 2D UI framework, rendered using OpenGL. In a wide range of applications and fields, this UI needs to be combined with existing rendering technologies and libraries, ideally in ways that minimise the impact on performance while still allowing the full feature set of Qt to be exploited.

Abstract:
"QtQuick in Qt5 uses OpenGL to deliver fluid, performant visuals, and an internal scene-graph structure to permit threaded rendering, decoupling the main application thread from interacting directly with the graphics driver. For developers work with an existing rendering or visualisation technology, this presents both an opportunity but also problems; QtQuick offers a compelling, modern 2D UI with many advantages.

Unfortunately most existing rendering libraries make strong assumptions about how they permit other code (such as Qt) to integrate with their rendering loop and data, and Qt Quick itself was not designed to support efficient integration into foreign rendering environments.

In this presentation will will investigate some of the problems, work-arounds and ultimate solutions encountered in integrating Qt Quick with different 3D renderers, including the changes necessary both in Qt and on the 3rd-party side. This will involve material on threading, OpenGL state management, and the internals of both Qt Quick and scene-graphs in general. To motivate the discussion, some real-world cases will examined and presented, including integration of Qt Quick with OpenSceneGraph, the Visualisation Toolkit (VTK) and (time-permitting) the Open Source Graphics Engine (OGRE).

Presenter Biography:
Working as a software developer at KDAB. James has been developing with Qt since 2002, and contributes to the current maintenance of Mac platform support, and the development of OpenGL and 3D support in Qt. James has a background in user-interface, graphics and simulation development, as well as a long history of development on OS-X and prior versions of Mac OS. He is a lead developer on FlightGear, the open-source flight simulator, and holds a B.Sc. in Computer Science.

10 1

QtDD13 - Anton Kreuzkamp & Thomas McGuire - QmlWeb -- Running QtQuick Applications on the Web

Recorded at the Qt Developer Days in Berlin in 2013.
Slides available at https://devdays.kdab.com/?page_id=225

Short Abstract:
QML is the language that makes writing application UIs easier than ever before. QmlWeb now brings this ease to the web.

While the demand has risen to use web technologies on the desktop, QmlWeb takes the opposite approach: The JavaScript library understands QML and renders QtQuick based applications to a website using the webbrowser's Document Object Model and CSS. In other words, QmlWeb enables to use modern desktop technologies on the web. Using e.g. QML's property bindings and QtQuick's anchor layouts allows you to do tasks like complex positioning and animations with just a single line of code.

This talk will provide an overview of what QmlWeb is, how it works, what its advantages and where its limits are. It will show how you can reuse knowledge from desktop development for web applications.

Abstract:
QML is the language that makes writing Qt application UIs easier than ever before. QmlWeb now brings this ease to the web.

Traditionally desktop applications were written in languages like C or C++. Web technologies like HTML and PHP were mainly used to write static websites. With the rise of modern web applications and technologies like HTML 5, CSS 3 and ECMAScript 5, those technologies became more and more popular. But technological development on the desktop side continued as well. Modern technologies like QML + QtQuick allow us to write complex user interfaces easier than ever before in a declarative manner.

For companies the separation between desktop and web technologies means that they have to maintain two seperated groups of developers, one for doing desktop applications, and one for web development. Because of that the demand has risen to use web technologies on the desktop and especially for mobile applications as well.

QmlWeb takes the opposite approach. The JavaScript library understands QML and is able to render a QtQuick based application to a website using the webbrowser's Document Object Model and CSS. It is capable of property bindings, anchor-layouting and most kinds of simplifications offered by QML. Impressive animations are only a few simple lines of QML code away. States and components help to keep even complex applications well-stuctured and easy to read. Many of the little pains webdevelopers often have to struggle with are becoming just a single line of QML code.

To achieve this, QmlWeb e.g. implements a system to track dependencies between properties and automatically update dependant properties on change. Positioning, which is one of the most inconvenient things in CSS, is completely done in JavaScript and then exposed to the browser using absolute positioning in CSS.

The talk will provide an overview of what QmlWeb is, how it works internally and what its current state of development is. It will demonstrate how developers can reuse their existing knowledge from the desktop for web applications. Therefore, it will include a live demo, in which a small web application using QmlWeb will be written. The talk will show what pieces of QtQuick are supported, what is still missing and also what features QmlWeb adds to match with the web. QmlWeb will be compared to other technologies to display where its advantages and where its limits are. At the end the audience should have an idea of what QmlWeb can do and should be able to decide whether QmlWeb could be suitable for his/her next web application.

Presenter Biography:
Anton Kreuzkamp is member of the KDE community since 2010, supporting Rekonq and Plasma development, where he first got in touch with QML. Anton started to work on QmlWeb during the last year within the context of his graduation from secondary school in 2013. By now, he is the main developer of QmlWeb.

30 2

QtDD13 - Milian Wolff - Apps on Speed

Recorded at the Qt Developer Days in Berlin in 2013.
Slides available at https://devdays.kdab.com/?page_id=225

Short Abstract:
Fast code is important -- just think of performance constrained embedded platforms. But how do you make your C++ application faster?

This talk will show you how to find bottlenecks in a C++ program using various tools. Then we will look into some solutions to common issues and top it off with some guidelines for new code.

Abstract:
Often one might think: Machines get faster and faster, thus it gets less and less important whether my code runs fast or not.

False! Making your applications faster is more important than ever, especially when you target embedded devices or battery powered devices. And even on the desktop your users will appreciate fast applications that do more in less time.

In the talk I'll present the most useful tools I know for investigating the performance of a C++ application. We will look at various issues, such as memory consumption, finding CPU hot spots but also at some more complicated threading related performance problems like lock contention. For each issue I will try to present some motivating code example and show you how to improve your code to achieve a better performance.

Presenter Biography:
I work at KDAB as a Software Engineer and contribute to KDE for quite some years now. There I am one of the most active contributors to KDevelop and Kate. Tooling in general is of huge interest to me, I wrote the Massif-Visualizer, played around with a GDB based profiler called Pace and also looked into tooling around Linux malloc to investigate memory fragmentation issues. At KDAB I also worked on GammaRay which is invaluable to any Qt developer.

4 1

QtDD13 - Bogdan Vatra - Step by step Qt on Android tutorial

Recorded at the Qt Developer Days in Berlin in 2013.
Slides available at https://devdays.kdab.com/?page_id=225

Short Abstract:
This step by step tutorial is an introduction on how to setup and use Qt Creator to create, deploy, debug sign and publish Qt apps for Android.

Abstract:

The tutorial will start with instructions on how to setup the development environment, how to configure QtCreator and ensuring that all dependencies are met.

It will then continue with a live demonstration on creating an app, deploying it to an Android device and debugging it there.

Once the app runs satisfactorily, the demo will continue by showing how to publish it to the Google Play store, including necessary steps such as signing the package.

The rest of the presentation's time slot will be used to introduce the audience to the inner workings of Qt on Android, explaining how it works together with the platform's Java stack and how to further extend platform integration for application specific needs.

Presenter Biography:
Bogdan has been using Qt since 2002 and is the author of Qt for Android port. He is an active KDE (Necessitas) and qt-project contributor.

59 6

Designing value classes for modern C++ - Mark Mutz @ Meeting C++ 2014

Designing value classes for modern C++
Mark Mutz

Meeting C++ 2014
Slides: http://meetingcpp.com/index.php/tv14/items/5.html

28 5