Effective HMI interaction and safety attention monitoring using eye tracking technology: DeepGlance Quick

Interacting effectively with increasingly widespread and advanced systems is one of the most important challenges of our time. Most modern HMIs are based on mouse, keyboard or touch screen and allow controlling even very complex devices in a simple and intuitive way. However, in certain contexts, the user may be unable to have direct contact with a device, in this case, we are talking about hands-free interactions and often voice commands are used to interact. But controlling a system by voice, however natural, is not effective for all types of operations and in all environments. In fact, every technology has its peculiarities, that’s why the HMI design and the UX are the subject of continuous research and aim to offer increasingly effective and natural interaction methods, also thanks to the combined use of more complementary technologies between them.

Eye tracking technology

Eye tracking is an innovative technology that allows you to accurately estimate where a person is looking, instant by instant, through the use of dedicated devices. Today this technology is spreading more and more thanks to the reduction of costs, the miniaturization of the devices and the high degree of reliability achieved.

Knowing the direction of the gaze allows a system to understand in an immediate way which element we are interested in and to which we want to issue commands, avoiding having to move a cursor or touch a surface. Knowing where we look, a system can also make a page or image scroll automatically, always offering the best frame with respect to the point of interest. The gaze is also related to our attention and attention monitoring is essential when we carry out particularly critical operations.

DeepGlance Quick

image1

The DeepGlance team has over 15 years of experience with this technology and its applications in the main markets, including medical, healthcare, automotive, retail and entertainment.

The current barrier to integrating this technology is that it requires an important initial effort related to specific knowledge of how eye movements work, device management and how to transform low-level data returned by an eye tracker into high-level behaviors necessary to control a system.

This leads to DeepGlance Quick, a QML extension plugin that encapsulates the complexity linked to the use of eye tracking technology and that allows anyone to integrate it immediately into their own Qt application. In fact, through the use of the plugin within Qt Design Studio it is possible in a few minutes to create and test gaze-controlled applications or add eye tracking functionality to existing Qt projects.

DeepGlance Quick was presented for the first time at the SPS IPC Drive Nuremberg 2018, the most important European exhibition for industrial automation, gathering great enthusiasm among the insiders.

image2

How to get started using Qt Design Studio

Before starting, make sure you have installed Qt Design Studio 1.0.0.

An eye tracking device is required to control the application, but If you do not have one, you can use the eye tracker simulator provided by the plugin.

As a first step, download the DeepGlance Quick package.

The Tobii Stream Engine library is a dependency and it is distributed in the plugin package. You must be sure that the Qt Design Studio and your application can find it by copying it to a folder in your system path.

The following example uses an EyeArea in a Rectangle that changes the Rectangle color to red when observed for a certain amount of time:

image3

To get started, create a new Qt Design Studio project named HelloWorld and copy the DgQuick plugin folder in the “imports” directory.

Modify HelloWorld.qml adding the plugin types:

import QtQuick
import DgQuick
import HelloWorld

Item {
  width: Constants.width
  height: Constants.height

  Screen01 {
  }

  EyeTracker {
      model: EyeTracker.ModelTobii
      Component.onCompleted: start()
  }

  ErrorHandler {
      onError: {
          if (error === ErrorHandler.ErrorEyeTrackerSoftwareNotInstalled) {
              console.log("Tobii software not installed");
          } else if (error === ErrorHandler.ErrorEyeTrackerNotConnected) {
              console.log("Tobii eye tracker not connected");
          }
      }
  }

  EventHandler {
      anchors.fill: parent
  }
}

EyeTracker type is used to control the eye tracker device, ErrorHandler to handle the errors and the EventHandler to forward the mouse and keyboard events to the plugin.

To use the simulator just set the EyeTracker model property to EyeTracker.ModelSimulator.

Add EyeButton.qml:

import QtQuick 2.10
Import DgQuick 1.0

Rectangle {
   width: 100
   height: 100
   color: "green"
   EyeArea {
       anchors.fill: parent
       onAction: { parent.color = 'red' }
   }
}

The EyeArea is an area that is gaze-sensitive, it is is the main component of the DeepGlance Quick plugin.

Finally, modify the Screen01.ui.qml adding the EyeButton:

import QtQuick 2.10
import HelloWorld 1.0

Rectangle {
  width: Constants.width
  height: Constants.height

  EyeButton {
      anchors.centerIn: parent
  }
}

For more information and details please refer to the official documentation.

Hands-on experience

Eye tracking is one of those technologies whose potential is fully understood only by experiencing it firsthand.

For this reason, the DeepGlance Plugin was used to develop a demonstrator that collects the main interactions which may be carried out using eye tracking technology.

Take a look at the tutorial video.

You can download the demonstrator at the link below:

http://www.deepglance.com/deepglance-explorer-download
image4

Interaction and Experience design

Technology is not enough to create natural interfaces and valuable user experience, it is necessary to create a design focused on the engagement and involvement of users. For that reason, DeepGlance has started a collaboration with the Interaction & Experience Design Research Lab of the Polytechnic University of Milan, whose design department is ranked 6th in the world. Recently, during the workshop “New paradigms for HC interaction and eye tracking driven interfaces” realized in collaboration with Qt, the students of Digital and Interaction Design have designed solutions that integrate eye tracking technology. And thanks to the integration of DeepGlance Quick in Qt Design Studio they quickly developed working prototypes of the projects.

image5

image6

Use cases

use-cases

There are many applications where eye tracking technology can add value.

In the medical field, there is often the need to consult images, information or check systems in contexts where hands cannot be used. This is what happens for example for the operations of robotic surgery in which the surgeon has his hands engaged with the manipulators for the control of the robotic arms. In this case, the gaze is used to make adjustments, decide which robotic arm to associate with the right or left hand, automatically move the robotic endoscope camera based on the point of interest by providing always the best view and finally to make sure that the surgeon’s attention is focused while he is controlling the system. In robotic surgery, the gaze is often used as a method to select and a single physical button mounted on the manipulator is used to confirm an action.

Eye tracking technology is widespread in the healthcare field to allow communication to patients in different clinical conditions such as Cerebral Palsy, ALS, Autism, Spinal Cord Injury. It is used to create personal communication and entertainment systems in a home or clinical / hospital environment controlled exclusively with the eyes and that allows the patient to write and vocalize messages, send emails, browse books, surf the Internet, control television, home automation systems and more.

In the field of retail, events, exhibitions and interactive museums entertainment, gamification and shopping experience systems can be developed to offer the visitor an engaging experience, contrast the “showrooming” effect, increase the time spent in the store / stand and ennobling the image of the brand with a “cool” and innovative experience.

For the creation of information points for hotels, airports, shopping malls, real estate agencies, shop windows to present content adapted to the user’s interest, profile prospects in relation to the content consumed and use information in a confidential manner, that is without making no gesture or touch the display.

As an alternative method for interacting with vending machines for drinks, snacks, tickets, orders to avoid having to use hands exclusively to interact, for reasons of hygiene, comfort and to offer an innovative experience to the consumer.

In the marketing field to effectively present promotions and offers, increase the exposure of the prospect to the message that the brand wants to convey, reach an audience that is not currently interested in the message or product, and open a quality two-way communication channel with it also through cross-media marketing.

In the control rooms, it is possible to improve the efficiency of the operators through a multimodal interaction, that is by combining eye tracking with traditional inputs to show information in an adaptive and contextualized way and interact more quickly and naturally.

In the automotive sector, it is possible to monitor the attention of the driver detecting any distractions and allow to interact with the instrumentation on board in a more effective and safe way. For example, understanding the target of a voice command or automatically selecting the element or device with which to interact with the joystick on the steering wheel.

In short

DeepGlance Quick is a plugin that allows you to integrate and test eye tracking technology in your Qt application in an immediate and effortless way, transforming a traditional interface, into a gaze-controllable interface. Eye tracking can be used as an exclusive input method or in combination with other technologies, to make the interaction more effective and natural, taking the most of each of them in a complementary way. On the machine side, it can be used to monitor the attention of an operator and adapt the information shown in an interface based on the elements of interest to the user.

More info:

http://www.deepglance.com

info@deepglance.com

The post Effective HMI interaction and safety attention monitoring using eye tracking technology: DeepGlance Quick appeared first on Qt Blog.

Dude, desktop applications are so last decade!

Desktop applications may not be the future. In the future, we will put on those goggely thingies and immerse ourselves in a digital world of wonder. A world entirely hosted on servers in safe locations. Servers owned and operated by benevolent companies not at all interested in our private lives. The bandwidth between our goggely thingies and the cloud is unlimited. The connection never breaks down and the data transfer is instant. In this future, there are no malicious hackers lurking around. Safety is intrinsic and absolute. Certainly this is the future, but currently, it remains the future.

Every day, millions of users around the globe depend on desktop applications in order to do their job. Applications controlling systems for electrical power, water, renovation and banking services – just to name a few. We all depend on desktop applications, though we all tend to live more and more in the cloud. There is a multitude of reasons for building desktops applications. Security, control, stability, complexity and network access are just a few of them.

Desktop applications may not be the future, but they are for sure a large part of the present. Desktop applications will not vanish overnight, they will evolve and adapt to the changing needs. While the future remains the future, Qt will be here to support you in creating the desktop applications of tomorrow.

With this in mind, I invite you to have a look at some of the latest success stories written with Qt:

If you’d like to hear more, join me for a live and interactive webinar where I will talk about new and upcoming helpful features, developer experience improvements, and answer your questions related to the present and future of Qt for desktop targets.

EMEA Time AMER Time
Webinar: Desktop Applications in 2019 – The Qt Perspective. Apr 11, 2019 (2pm CEST) Webinar: Desktop Applications in 2019 – The Qt Perspective. Apr 11, 2019 (2pm EDT)

 

 

The post Dude, desktop applications are so last decade! appeared first on Qt Blog.

KDAB at QtDay 2019

On the 1st and 2nd of April, KDAB will once again be sponsors at this fast-growing Qt event in Italy: QtDay 2019.

The biggest Qt event in the region, now in its 8th year, contrary to what its name suggests, QtDay 2019 boasts a full two days of technical talks and workshops, each day with two to three tracks.

KDAB has a talk in the program on each of the days. On Day 1, straight after the Keynote from Thiago Macieira of Intel, KDAB’s Mike Krus will talk about Streamlined integration of 3D Content straight from 3DS Max and Blender into Qt3D. On Day 2, also at 10:45 am, KDAB’s Giuseppe D’Angelo will offer Optimizing the Rendering of Qt Quick 2 applications

You can see the full agenda here.

KDAB will be showing two new demos at this event: QiTissue, a desktop Application developed for Quantitative Imaging Systems (Qi) to help cancer researchers efficiently handle gigabytes of data (see more about that here), and KUESA for Qt3D, on Embedded, which demonstrates the designer/developer workflow expounded in Mike’s talk on Day 1.

We look forward to seeing you in Florence at the Grand Hotel Baglione on April 1st and 2nd. Meet us there.

 

 

 

The post KDAB at QtDay 2019 appeared first on KDAB.

Qt 5.13.0 Beta1 released

I am happy to announce that Qt 5.13.0 Beta1 is released today. As earlier we release updates as Beta N regularly until we are ready for RC. Current estimation for RC is 7th May 2019, see the schedule from 5.13 wiki.

Beta1 (and later releases) can be installed by using online installer as usual. Commercial users can found online installer from their Qt Account and Opensource users from download.qt.io. We are not planning to blog next Beta releases or RC so please follow mailing lists to get the notification when new ones are available. And of course you can use maintenance tool’s update option to check if there is update already available.

I hope you will now start testing Qt 5.13 beta release(s) and report your findings via Jira. It is really important to do the testing now; we need to understand the release status and recognize release blockers as soon as possible to be able to get the final release out as planned. So please install beta1 now & update it regularly with latest changes. And please make sure all release blockers can be found from release blocker list.

From Qt 5.13 New Features page you can find the details what new Qt 5.13 release contains.

The post Qt 5.13.0 Beta1 released appeared first on Qt Blog.

Customization of a QCompleter

Time ago I had the task to create a QComboBox and a QLineEdit that open a completer so the user can select between all the suggested options. So far it seems a quite easy task by using the QCompleter that Qt provides.

The interesting part starts when I had to add customized styles for both the QComboBox and the QLineEdit, and make them match with the styles that I also had to add to the QCompleter. In addition I had a language constraint that initially I didn't take into account but it impacted the performance of the widget. That's the default filter implemented in QCompleter.

La entrada Customization of a QCompleter aparece primero en My C++ & Qt blog - Cesc M..

Using QNanoPainter without QtQuick (pure C++)

Originally, QNanoPainter library was implemented to fulfill the needs of easy to use but performant custom OpenGL QQuickItems. For the needs, Qt Quick Scene graph QSG* classes felt a bit too low-level to be productive, while QQuickPaintedItem was slightly lacking in performance and rendering quality on mobile hardware. For more details, please read this QNanoPainter introduction blog post.

I like (OK, love) Qt Quick & QML and have used them successfully in many different projects. On desktop, mobile and embedded software. A lot. But Qt Quick doesn't suit all situations or it is not always required. As explained in this Qt blog post, Qt 5.12 improves Qt Quick performance and memory usage. But naturally there still is some memory and startup time additions coming from Qt Quick engine.

Fear not, QNanoPainter can be used also without Qt Quick. Available entry points are:

  1. QNanoQuickItem & QNanoQuickItemPainter - This is where it all started, use these to implement your QQuickItems.
  2. QNanoWidget - Based on QOpenGLWidget so can be used for widget based applications. Used similarly to QWidget and just contains QNanoPainter API for painting instead of QPainter. As QNanoPainter is OpenGL (ES) powered, in some cases this can substitute also QGLWidget based components.
  3. QNanoWindow - Based on QOpenGLWindow / QWindow so very lightweight. Optimal for embedded software which would only need a single QNanoWindow for the whole UI.
There are separate helloworld examples for all of these classes in QNanoPainter sources, so to educate ourselves let's see what the memory consumption differences of them are. First I unified all examples to look the same, like this:


Also made applications to exit automatically with timer after running for 2 seconds, to let the memory consumption stabilize. Measuring was done using MTuner memory profiler for Windows. Using freshly released 5.12.2, MTuner memory usage graphs look like this:


So QNanoQuickItem based version is using most memory, peaking at 28.9MB. QNanoWidget comes next with 23.3MB peak usage. And slimmest, as expected, is QNanoWindow app with 19.0MB.

Note that all of these use normal MSVC2015 Qt 5.12.2 from installer and release builds of applications, without extra compiler options or anything. With those and Qt Lite it would be possible to build more streamlined versions especially for QNanoWindow which doesn't depend on other Qt modules than Qt Core & GUI. Further optimizations and testing is left as an exercise for readers and the ones needing it :)

In conclusion: If you are working on embedded device with OpenGL ES 2 / 3 capable GPU, concerned of flash & RAM usage and require relatively simple user interface, I would encourage to check out QNanoWindow. You get hardware accelerated nicely antialiased graphics, in pure C++.

Qt 5.12.2 Released

I am pleased to announce that the second patch release of Qt 5.12 LTS, the Qt 5.12.2 is released today. While not adding new features, the Qt 5.12.2 release provides a number of bug fixes and other improvements.

Compared to Qt 5.12.1, the new Qt 5.12.2 contains more than 250 bug fixes. For details of the most important changes, please check the Change files of Qt 5.12.2.

With Qt 5.12.2 we bring back widely asked MinGW 32 bit prebuild binaries in addition to 64 bit ones.

Qt 5.12 LTS will receive many more patch releases throughout the coming years and we recommend all active developed projects to migrate to Qt 5.12 LTS. Qt 5.9 LTS is currently in ‘Strict’ phase and receives only the selected important bug and security fixes, while Qt 5.12 LTS is currently receiving all the bug fixes. With Qt 5.6 Support ending in March 2019 all active projects still using Qt 5.6 LTS should now migrate to a later version of Qt.

Qt 5.12.2 is available via the maintenance tool of the online installer. For new installations, please download latest online installer from Qt Account portal or from qt.io Download page. Offline packages are available for commercial users in the Qt Account portal and at the qt.io Download page for open-source users. You can also try out the Commercial evaluation option from the qt.io Download page.

The post Qt 5.12.2 Released appeared first on Qt Blog.

Testing QTableWidget with QTest

In the last post I talked about how to integrate tests in the build environment. When we talk about testing I always think on unit testing for my classes and methods but I usually forget UI testing.

With Qt we have a really nice environment to test GUI as well. Widgets implement all the power of signals and slots, and Qt provides a wide range of signals so we can keep track of what happened and what's currently happening. The fact that we can work with QSignalSpy makes all or testing easier. At least if we know what to test, because some times is not that straight-forward with widgets. Specially with QListWidget, QTableWidget and QTreeWidget classes.

La entrada Testing QTableWidget with QTest aparece primero en My C++ & Qt blog - Cesc M..

Announcing QtLottie

QtQuick was designed to be useful for both software developers and for UX designers. Ideally this would be a seamless blend of the two, but very often this ends up with the designers desiging things with Adobe tools, and the engineers working from PDFs, JPGs, etc to recreate what the design team want. In the case of complex animations this can mean recreating everything entirely in code.

Wouldn’t it be much easier if they engineers could just embed the designers’ animations directly in the UI?

Engineers over at Airbnb thought the same, and in 2017 released their way of doing it.

The BodyMovin plugin is an After Effects plugin that exports the animations to a JSON format, which can be run on the web. The Airbnb engineers created a native iOS and Android runtime library for these JSON files, called Lottie. This allows embedding and replaying of the BodyMovin JSON files. The idea picked up quickly, and if you have an iOS or Android device of your own, you most likely have something using Lottie on there somewhere.

With the release of Qt 5.13, we are happy to introduce a new Qt-based Lottie player. This gives engineers and UI designers the ability to embed Adobe After Effect animations directly into QtQuick applications, without any need to rebuild the animation using code later on. We are at the Technical Preview stage, so not all features are supported yet and you may find downloaded Lottie files don’t always work. We will look deeper at the technical details in a future blog post.

Internally, the BodyMovin JSON files are rendered in an embedded renderer – a micro renderer if you will. This parses and loads the JSON, and then runs the animations, trimming, layers, and other effects. This is wrapped up in the LottieAnimation QML element, which can be controlled by the QML code in the UI just like any other QtQuick element.

QtQuick already offers a powerful toolkit for making smooth, powerful, animations to designers. This complements it nicely, offering designers the ability to embed animations quickly and easily.

Using Qt Lottie is as straightforward as any other QtQuick element. Add the element to your QML file, specify what it’s properties are, and define it’s behavior, using JavaScript where necessary. The second video has a little ‘mouse twinkle’ effect, which is also created using a Lottie file:


    MouseArea {
        anchors.fill: parent
        onClicked: {
            sparkle.anchors.horizontalCenterOffset = (window.width/2 - mouseX) * -1
            sparkle.anchors.verticalCenterOffset = (window.height/2 - mouseY) * -1
            sparkle.opacity = 1.0
            sparkle.gotoAndPlay(0)
        }

        LottieAnimation {
            id: sparkle
            anchors.centerIn: parent
            scale: 0.15
            source: ":/4436-celebrating-stars.json"
            autoPlay: false
            frameRate: 20
            onFinished: fade.start()
            PropertyAnimation {
                id: fade
                target: sparkle
                property: "opacity"
                to: 0.0
                duration: 2000
                easing.type: Easing.InOutQuad
            }
        }
    }

Our sample above moves the animation to the position of the mouse click, starts the Lottie animation running from the beginning, and then fades it out when the animation emits the ‘finished’ signal. Another quick sample here:
heart


// LottieHeart.qml
import QtQuick 2.0
import Qt.labs.lottieqt 1.0

Item {
    id: root
    property bool selected: false
    Image {
        id: backgroundImage
        anchors.fill: parent
        source: "heart-outline.png"
    }
    LottieAnimation {
        id: animation
        anchors.centerIn: parent
        source: ":/3990-favheart.json"
        scale: 0.4
        autoPlay: false
    }
    MouseArea {
        anchors.fill: parent
        onClicked: {
            if (root.selected) {
                animation.gotoAndStop(0)
            } else {
                animation.gotoAndPlay(0)
            }
            root.selected = !root.selected
        }
    }
}

A simple little click on/off favorites button.

You’ll notice in the sample code that both of my Lottie animations are scaled. This isn’t something you will normally need to do if you are creating your JSON Lottie files from scratch, but in this case I am using Lottie files downloaded from a public repository, and I scaled them to fit.

If you are ready to take a look, you can get hold of Lottie already using the Qt online installer – it’s available with the 5.13 alpha release. You can also grab the code from the Qt repository on github. If you don’t have a copy of After Effects, there are several thousand ready made Lottie animations available from lottiefiles.com. Be aware that Qt Lottie supports a subset of all the BodyMovin features, and not all of the files will play, but don’t despair, many will. You can get the source for the little test app in the first video from here, and the Qt Lottie source code contains a test app with some very simple reference Lottie files that can be used for calibration.

The Qt Lottie documentation is here.

The post Announcing QtLottie appeared first on Qt Blog.

QML Tutorial: How to Create Native Cross Platform Apps with Qt and Felgo | Free Udemy Course

Learn to build Qt-based cross platform apps for Windows, Mac, Linux, iOS and Android with QML and Felgo (former V-Play)! We created a comprehensive online course on Udemy to show you how:

The online course is a perfect fit for both beginners and advanced developers, as it contains many QML best practices and QML architecture tips.

And the best part: The course normally costs 129,- €, but is 100% FREE for all Felgo developers. Just sign-up now and retrieve the coupon code along with your first welcome email after sign-up. As a registered Felgo user, you can find the code in the newsletter email about this post.

Which Topics Does the Udemy Course Cover?

The complete Udemy course contains 44 lectures and more than 4 hours of video course material. It focuses on many important topics for beginners and advanced developers. With the full QML tutorial you will learn:

  • How to use QML to create desktop and mobile apps in ultra fast time
  • Make good looking and scalable layouts using QML
  • Use Felgo to create mobile versions of your app – without any extra code
  • Understand how to make HTTP API calls and deliver the data to your app
  • Learn how to leverage events and button clicks in Felgo
  • Correctly structure apps in QML and QtQuick

The end result of the course is a real estate app for mobile and desktop platforms.

Udemy QML Tutorial Real Estate App

The app also uses the Felgo SDK for advanced Qt tooling (e.g. live code reload on Desktop and mobile) and extended Qt APIs for usage on mobile. You can find the final demo app, as well as many other demos, in the Felgo Apps Examples and Demos.

Why learn Qt and QML on Udemy?

Udemy is one of the biggest online learning platforms and used by over 30 million students from around the world! Learn at home, the office, waiting in line, or on the go. Udemy offers a vast set of online courses: Web Development, Mobile Apps, Programming Languages, Game Development, Databases, and more.

You can find this first official Felgo course on Udemy here: Learn Qt and QML by Creating Cross Platform Apps with Felgo

Udemy

The course is for beginner and intermediate levels and covers many topics. See the course outline for a quick overview of what to expect:

  • Introduction to Qt, QML and Felgo
    • Introduction
    • Is this Course For you?
    • Installation
  • Creating the Project, Understanding File Structure and Running It
    • How to Create a Blank Mobile App using Qt and QML
    • Understanding Files and Folders
    • Running the Basic App Locally
    • How to Run the App on Multiple Devices Simultaneously with Live Code Reload
  • Structuring a Project and Your First Piece of Code
    • Explaining the Existing Code (Navigation Stack, Pages and Content)
    • Structuring an App Correctly with an Item Object
    • Creating the Main Page of the App
  • Understanding QML Layouts, Property Listeners and Button Click Events
    • Creating a Basic Search Page
    • Adding a Sensible Layout with Columns and Rows
    • Adding Input and Text Elements to a QML Page
    • Events and Listeners to Detect Changes in Input Text
    • Buttons and Click Events
  • Retrieving Remote Data using Signals and Logic (Equivalent to Events)
    • Making a Simple HTTP API Request Using HttpRequest
    • Creating a Client to Store Http Requests and Tidy up Code
    • Creating Search Client Functions
    • Communicating Between QML Objects Using Signals
    • Communicating with Signals – Firing a Signal
    • Subscribing to a Signal
    • Creating and Handling Callbacks for Received Data
  • Creating Scrolling List Views
    • Creating Logic to Parse Received Data
    • The Data Received Signal
    • Creating a List View – Making a List Page
    • Creating a List View – Showing Listings
    • Creating a List View – Showing a New Page and Passing Data to it
    • Searching for the Next Page of Listings and Fixing the Loading Icon
  • Implement Favorites using Arrays and Local Storage
    • Checking for Favorites
    • Adding and Removing Favorites Using Signals
    • Showing Existing Favorites
    • Persisting Favorite Data Across App Launches

We plan to add many more courses and lectures in the future, so be sure to check it out!

Don’t hesitate to leave a review if you like the course! 😉

 

In case you run into issues or have a business request in regards to Felgo apps, don’t hesitate to contact us here.

 

 

More Posts Like This:

mobile-ui-design-how-to-make-the-perfect-app
Mobile UI Design: Make mobile app design that stands out in 2018

mobile-app-ideas-and-where-to-find-them
Best Mobile App Ideas: 6 Sources That Will Make You Think!

how-to-make-an-android-app
Step-by-step guide to your first Android / iOS App | Guide for 2019

The post QML Tutorial: How to Create Native Cross Platform Apps with Qt and Felgo | Free Udemy Course appeared first on Felgo.

Auto Innovation at Embedded World

In vehicle infotainment systems and instrument clusters are getting larger and more complex, requiring an exponentially growing base of software to drive them. Furthermore, KDAB finds that self-driving technology does not obviate the need for displays – in fact, autonomous technology seems to be accelerating the trend for larger and more capable graphics software.

To help meet this challenge, KDAB showcased a number of innovations at this week’s Embedded World 2019 in Nuremberg, Germany, where we focused on three key aspects of in-vehicle embedded displays: optimizing code, eliminating bugs, and adding 3D graphics.

Optimization is important in automotive systems since it allows for lower priced, lower powered processors to smoothly render complex graphics, giving automakers an edge in creating distinctive displays while still using cost effective parts. KDAB provides a number of tools that help developers optimize their code, such as the KDAB Gamma Ray inspector that allows visual debugging of Qt application structures, state machines and models, the KDAB Hotspot Profiler that gives programmers insights into the areas of their system that are consuming excess CPU cycles, and the Heaptrack Profiler that analyzes a program’s memory use and behaviour so that engineers can ensure the system consumes memory properly and won’t exhaust that precious resource.

Having bug-free code is important for all software but since few people appreciate rebooting their cars there is an especially high quality bar for automotive systems. To help with that, KDABian Sergio Martins created the open source tool Clazy, a static analysis tool that finds problems lurking in Qt source code. Not only does Clazy find all manner of Qt-related bugs, performance sinks, and unneeded memory usage, it also helps rewrite code to adopt improved constructs and newer syntax, and easily integrates into existing build systems.

The last item of interest to automotive developers – but certainly not the least – is KUESATM for Qt 3D, a designer/developer workflow solution that helps streamline the creation and deployment for 3D content in both embedded and desktop applications. Three-dimensional models are being increasingly used in cars for realistic looking digital instrument clusters, diagnostic car model displays, and sophisticated user interfaces. KUESA removes the barriers that traditionally exist between designers and developers, and allows each team to use best-in-breed tools of their choice. With KUESA for Qt 3D, designers and artists can create professional and attractive 3D assets that are easily imported and manipulated by software engineers for real-time rendering in a Qt 3D application – perfect for next generation in-vehicle displays.

If you weren’t able to make it to the KDAB booth at Embedded World, check out the rest of our website to learn more about all of these automotive-related items and much more.

 

The post Auto Innovation at Embedded World appeared first on KDAB.

Qt Creator 4.9 Beta2 released

We are happy to announce the release of Qt Creator 4.9 Beta2!

Please have a look at the blog post for the Beta for an overview of what is new in Qt Creator 4.9. Also see the change log for a more complete list of changes.

Get Qt Creator 4.9 Beta2

The opensource version is available on the Qt download page under “Pre-releases”, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.9 Beta2 is also available under Preview > Qt Creator 4.9.0-beta2 in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

The post Qt Creator 4.9 Beta2 released appeared first on Qt Blog.

Using Docker to test Qt for WebAssembly

There has been lots of excitement around WebAssembly and more specifically Qt for WebAssembly recently. Unfortunately, there are no snapshots available yet. Even if there are, you need to install a couple of requirements locally to set up your development environment.
I wanted to try it out and the purpose of this post is to create a developer environment to test a project against the current state of this port. This is where docker comes in.
Historically, docker has been used to create web apps in the cloud, allowing to scale easily, provide implicit sand-boxing and being lightweight. Well, at least more lightweight than a whole virtual machine.
These days, usage covers way more cases

  • Build Environment (standalone)
  • Development Environment (to create SDKs for other users)
  • Continuous Integration (run tests inside a container)
  • Embedded runtime

Containers and Embedded are not part of this post, but the highlights of this approach are

  • Usage for application development
  • Resources can be controlled
  • Again, sandboxing / security related items
  • Cloud features like App Deployment management, OTA, etc…

We will probably get more into this in some later post. In the meantime, you can also check what our partners at Toradex are up to with their Torizon project. Also, Burkard wrote an interesting article about using docker in conjunction with Open Embedded.
Let’s get back to Qt WebAssembly and how to tackle the goal. The assumption is, that we have a working project for another platform written with Qt.
The target is to create a container capable of compiling above project against Qt for WebAssembly. Next, we want to test the application in the browser.

1. Creating a dev environment

Morten has written a superb introduction on how to compile Qt for WebAssembly. Long-term we will create binaries for you to use and download via the Qt Installer. But for now, we aim to have something minimal, where we do not need to take care of setting up dependencies. Another advantage of using docker hub is that the resulting image can be shared with anyone.
The first part of the Dockerfile looks like this:

FROM trzeci/emscripten AS qtbuilder

RUN mkdir -p /development
WORKDIR /development

RUN git clone --branch=5.13 git://code.qt.io/qt/qt5.git

WORKDIR /development/qt5

RUN ./init-repository

RUN mkdir -p /development/qt5_build
WORKDIR /development/qt5_build

RUN /development/qt5/configure -xplatform wasm-emscripten -nomake examples -nomake tests -opensource --confirm-license
RUN make -j `grep -c '^processor' /proc/cpuinfo`
RUN make install

Browsing through the Docker Hub shows a lot of potential starting points. In this case, I’ve selected a base image which has emscripten installed and can directly be used in the follow up steps.
The next steps are generally a one-to-one copy of the build instructions.
For now, we have one huge container with all build artifacts (object files, generated mocs, …), which is too big to be shared and those artifacts are unnecessary to move on. Some people tend to use volume sharing for this. The build happens on a mount from the host system to the image and install copies them into the image. Personally, I prefer to not clobber my host system for this part.
In the later versions of Docker, one can create multi-stage builds, which allow to create a new image and copy content from a previous one into it. To achieve this, the remaining Dockerfile looks like this:

FROM trzeci/emscripten AS userbuild

COPY --from=qtbuilder /usr/local/Qt-5.13.0/ /usr/local/Qt-5.13.0/
ENV PATH="/usr/local/Qt-5.13.0/bin:${PATH}"
WORKDIR /project/build
CMD qmake /project/source && make

Again, we use the same base container to have em++ and friends available and copy the installation content of the Qt build to the new image. Next, we add it to the PATH and change the working directory. The location will be important later. CMD specifies the execution command when the container is launched non-interactively.

 

2. Using the dev environment / Compile your app

 

The image to use for testing an application is now created. To test the build of a project, create a build directory, and invoke docker like the following

 

docker run --rm -v <project_source>:/project/source -v <build_directory>:/project/build maukalinow/qtwasm_builder:latest

This will launch the container, call qmake and make and leave the build artifacts in your build directory. Inside the container /project/build reflects as the build directory, which is the reason for setting the working directory above.
To reduce typing this each time, I created a minimal batch script for myself (yes, I am a Windows person 🙂 ). You can find it here.

 

3. Test the app / Containers again

Hopefully, you have been able to compile your project, potentially needing some adjustments, and now it is time to verify correct behavior on runtime in the browser. What we need is a browser run-time to serve the content created. Well, again docker can be of help here. With no specific preference, mostly just checking the first hit on the hub, you can invoke a runtime by calling

 

docker run --rm -p 8090:8080 -v <project_dir>:/app/public:ro netresearch/node-webserver

This will create a webserver, which you can browse to from your local browser. Here’s a screenshot of the animated tiles example

animated_dws

 

Also, are you aware that there is also Qt Http Server being introduced recently? It might be an interesting idea to encapsulate it into a container and check whether additional files can be removed to minimize the image size. For more information, check our posts here.

If you want to try out the image itself you can find and pull it from here.

 

I’d like to close this blog asking for some feedback from you readers and get into some discussion.

  • Are you using containers in conjunction with Qt already?
  • What are your use-cases?
  • Did you try out Qt in conjunctions with containers already? What’s your experience?
  • Would you expect Qt to provide “something” out-of-the-box? What would that be?

 

The post Using Docker to test Qt for WebAssembly appeared first on Qt Blog.

Integrating Qt Test in Travis CI

Fur a long time I wanted to create a full Continuous Integration environment that uses Qt for both building apps and testing. In fact, one of the most important things for me was to find the right way to integrate Qt Test. For CI I've started to use Travis since it is one of the most widely used environments in GitHub. I took that decision after seeing other Qt projects (Musescore and Stellarium) using it.

La entrada Integrating Qt Test in Travis CI aparece primero en My C++ & Qt blog - Cesc M..

The future of documentation

“Honestly Qt’s documentation is pretty close to perfect, I wish other framework’s documentation were as good. Keep doing what you’re doing.”

“Documentation has always been top-notch”

“The documentation is great.”

These quotes are from you, the users of Qt. For someone like me, who works with documentation for a living, this is awesome. It’s extremely cool to work with docs that receive this kind of feedback from its users. In light of the sheer size of the project, it becomes even more impressive. The online documentation for Qt 5.12 spans over 18000 pages. It covers more than 3000 classes and QML types across more than 120 modules. It’s simply massive. So it probably doesn’t come as a surprise that we also get some suggestions regarding how we can improve the docs. Easier navigation, more code snippets, more examples, missing documentation (Qt3D, anyone..?) – these are all regulars. My personal favorite is perhaps not the nicest way of putting it, but it certainly does get the point across [0].

Okay, so what’s this all about, then, that makes me write a blog post about it?

The future of documentation: a workshop

Monday 11th and Tuesday 12th March, some of us that take pride in Qt’s documentation come together for a two-day workshop about documentation. The workshop takes place at The Qt Company’s offices in Oslo. We’re joined by colleagues from Finland and Germany. We’re lucky enough to have a technical writer from Luxoft join us as well, to help us understand more about what it’s like to work on Qt documentation from the outside. From developers and tech writers to product managers, we’re putting our heads together to figure out how we can improve our docs further. We want you to have more fun and get more things done.

The agenda is already on the wiki [1], along with some ideas about what we want to address. If you want to join us in this workshop, I’d be happy to welcome you aboard – get in touch with me so we can sort out the practicalities. But it doesn’t matter if you can’t join – I still want to hear from you out there. What can we do to improve the docs? Have you seen something done brilliantly in some other documentation set? (Yes, they’re brilliant, but don’t expect Qt docs to mimic IKEA assembly instructions anytime soon.) Perhaps you want to contribute to the docs, help out with some of the examples? Whatever it is, make use of the comment section to let us know about it. If you’re not a fan of the comment section, feel free to send me an email or look me up on IRC 🙂


[0] – “Your documentation examples are sometimes shitty in the sense that they cover only trivial cases, but not advanced ones.”
[1] – https://wiki.qt.io/Documentation_Workshop_2019

The post The future of documentation appeared first on Qt Blog.

Qt Creator 4.8.2 released

We are happy to announce the release of Qt Creator 4.8.2!

I failed to decide which individual bug fixes to highlight here, so please just have a look at our change log for details :).

Get Qt Creator 4.8.2

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.8.2 is also available through an update in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

The post Qt Creator 4.8.2 released appeared first on Qt Blog.

Qt Automotive Suite 5.12.1 released

I am happy to announce we have release Qt Automotive Suite 5.12.1 today.

This is first patch release for Qt Automotive Suite 5.12 LTS and it is based on Qt 5.12.1 release. As a patch release it doesn’t bring any new features but many bug fixes at the top of previous Qt Automotive Suite 5.12.0 release. We will continue releasing regular updates as new patch level release in the future; next update should be available few weeks after soon coming Qt 5.12.2 release.

You can get Qt Automotive Suite 5.12.1 as an update to existing Qt Automotive Suite 5.12.0 installation via maintenance tool. Or you can do clean installation by using Qt Online Installer which can be found from your Qt Account.

Please install Qt Automotive Suite 5.12.1 now & give us feedback via Jira.

The post Qt Automotive Suite 5.12.1 released appeared first on Qt Blog.

MQTT version 5 updates and how they apply to Qt MQTT

Previously I have been writing about how topics in messages can have a significant impact on the amount of data for publishing via MQTT. Since then the MQTT version 5 standard has been released and first implementations are available. Naturally, Qt MQTT follows along and this post will reflect how new features in the standard are available in our Qt for Automation module.

In this post, we will not go into every detail of the updated specification, but rather showcase some highlights and benefits for upgrading to the latest versions.

Also, before we forget, make sure to sign up for my upcoming webinar on the same topic. Tune in and discuss!

Topic Alias

As a reminder, the topic of a message is always sent uncompressed in clear text as part of the byte stream. For example, a sensor network reporting temperature values could have a topic hierarchy designed as

sensors/Europe/2af89b42-d2a6-11e8-a8d5-f2801f1b9fd1/Temperature

Consequently, the byte layout of a message has this shape:

mqtt5_post_1

This sums up to 71 bytes for each message, with 4 bytes containing the requested information.

In the previous post, we talked about methods like

  • Reducing the topic length
  • Combining multiple sensor values to enhance the overhead-information ratio.

MQTT5 introduces Topic Aliases which allow assigning IDs to a specific topic.

During the connection handshake, the client and the server agree on whether topic aliases are available and what the maximum number of topic aliases is. While ids are available, they can be assigned to topics. This assignment is done during a publish message. The new layout to send a message and concurrently set a topic alias looks like this:

mqtt5_post_2

For the first message, the data size is 74 bytes, three more than for a conventional publish. However, the second publication already benefits from this concept

mqtt5_post_3

The message size has been reduced to 11 bytes, simply by exchanging the topic with an ID and keeping the topic string empty. Starting from the second message this is a major improvement to reduce the required bandwidth.

It is important to note that topic alias assignments are only set for one connection. Other subscribers on this topic, especially ones that do not use topic aliases, will receive messages including the full topic. Alternatively, those connections can create their own topic alias matching. It is the responsibility of the server to forward topics with either the full topic, or a different alias.

Furthermore, topic aliases are not static. An alias can always be re-assigned to another topic.

 

Let’s move on by showcasing how to use this feature with Qt MQTT. Support for MQTT v5 has been added for Qt MQTT with Qt for Automation 5.12.

  • Connect with topic aliases

To set topic alias support for a connecting client, the QMqttClient needs to be updated before connecting to the server

const int userMaxTopicAlias = 9;

QMqttConnectionProperties userProperties;

userProperties.setMaximumTopicAlias(userMaxTopicAlias);

client.setConnectionProperties(userProperties);

[…]

client.connectToHost();


  • Verify that the server supports aliases

When a server connected, query that the server also supports topic aliases

const auto serverProperties = client.serverConnectionProperties();

const quint16 serverMaxAlias = serverProperties.maximumTopicAlias(); // Returns the number of available aliases

A connection can use up to the minimum of client and server topic aliases.

 

  • Publish a message while setting topic alias
const QMqttTopicName topic(QLatin1String("sensors/Europe/2af89b42-d2a6-11e8-a8d5-f2801f1b9fd1/Temperature"));

QMqttPublishProperties aliasProperties;

aliasProperties.setTopicAlias(2);

client.publish(topic, aliasProperties, msgContent, 1);

Internally, Qt MQTT stores the assignment to simplify follow up publications.

 

  • Publish follow up messages
client.publish(topic, msgContent, 1);

There is no need to add the properties for subsequent calls unless the purpose is to reassign an ID.

Qt MQTT tries to use topic aliases automatically unless a user specifies them. After a connection has been established and Qt MQTT recognizes support for using topic alias, it “converts” classic publish messages to use topic aliases until all available aliases have been assigned. It uses an internal cache for this purpose, which can be controlled by using above QMqttPublishProperties.

There is no heuristics included in that cache, thus we still recommend using topic aliases manually. It depends on the project to identify which topics are frequently used and which topics can create the biggest benefit by using aliases.

As a closing note, Qt MQTT also takes care of the subscribing end about topic aliases. The process is the same, with the server specifying the topic and alias match. Qt MQTT then tracks this relationship and passes the full topic string inside a QMqttMessage to not require user specific code for this.

If a user wants to know, whether a topic has an assigned alias, the publish properties of a QMqttMessage contain this information.

Properties everywhere

You might have recognized the usage of a publish property class above. This reveals a new concept introduced with MQTT 5. While staying a lean and simple to use protocol, efforts have been made to allow for more dynamic setups.

Properties can be embedded into the existing commands, but it is not a must to include them. Default values cover the most used scenarios or ensure a compatible behavior with MQTT 3.1.1. Providing a zero byte indicates no properties to be set.

All available properties and their matching commands are listed below:

mqtt5_post_4

For each command, a new property class has been introduced with version 5.12. Please check the documentation on how to precisely use them.

Security

Authentication has been updated in a major fashion within MQTT 5.0, to the extent that a new command AUTH has been introduced. After sending a connection request from a client to a server, the server might ask for further authentication information. This happens via sending an AUTH command including a Continue reason code. The client then needs to provide authentication data, which either leads to successful connection, the server asking for even more data or the connection being closed due to a failed authentication. There is no limit on the number of authentication steps.

The actual method used for authentication is decided on the server side. This can be for instance OAuth, or any other functionality integrated on the server side.

In Qt MQTT the QMqttClient has an authenticationRequested and authenticationFinished signal to reflect a notification from the server. Furthermore, the authenticate function has been introduced to send authentication data to a server.

What’s more?

Descriptive arguments can be used to provide more details on the content of messages. And even more, it is now possible to allow servers to provide error messages to a client. This can be of big help when implementing a communication protocol between a client and a server. The standard used to demand a disconnect in case of invalid behavior. It still does, but now a server can include either error codes or even error strings as guidance for the client or the developer.

Naturally, all these things are reflected in Qt MQTT.

We would like to understand more about your usage of this module and which features would be required most to make your project succeed faster. If you have any comments, feel free to get in touch with us either via the comment section, directly via email or catch me live during the upcoming webinar.

The post MQTT version 5 updates and how they apply to Qt MQTT appeared first on Qt Blog.

Qt Roadmap for 2019

It has been a great start into 2019! We recently released Qt 5.12 which comes with multiple performance improvements and thousands of bug fixes– it’s a great release to base your work upon. But we have more in the works: Python language bindings, tools for developers and designers, industry-specific offering, and a lot more. Indeed, 2019 looks to be another great year for Qt users!

It’s around this time of the year I sit down to write a blog post about our plans and roadmap for the coming year. Typically, some of the items have already been cooking for a while, but some are still plans in the making. If you want to look into the previous roadmap blog posts, here are the ones I wrote for 20162017 and 2018. There is always more to tell than what would reasonably fit in a blog post, but I’ll try to talk about the most interesting items.

Before diving any further into the new items planned for 2019, I would like to thank each and every Qt developer for their contribution. We have a great ecosystem with many contributors who have provided multiple extremely valuable contributions throughout the years and continue to shape Qt in the future, too. In addition to those contributing code, we also have many active people in the Qt Project forums, on mailing lists, as well as reviewing code and testing the Qt development releases.

The Baseline: Qt 5.12 LTS

A lot of our efforts in 2019 will go into further improving Qt 5.12 LTS via multiple patch releases providing error corrections and performance improvements. Qt 5.12 LTS is the third long-term supported Qt 5 release and as such already a great baseline for developing applications. In Qt 5.12.0 we have fixed over 5000 bugs since Qt 5.6.3 and over 2000 since Qt 5.9.7. As all fixes currently go to Qt 5.12 LTS we take further steps ahead of the earlier LTS releases with each Qt 5.12 LTS patch release. In addition to fixing bugs and developing new features, we have put a lot of effort into improving performance and resource consumption of Qt applications – especially those using Qt Quick and Qt 3D Studio. Qt 5.12 LTS added several new features too, and contains all the cool features of earlier Qt 5.11 and Qt 5.10 releases since the previous LTS release of Qt.

With Qt 5.6 LTS support ending in March 2019 and Qt 5.9 LTS being in the Strict mode (receiving only the most important fixes) we advise migrating to Qt 5.12 LTS. Not only will your Qt application run faster and better thanks to the bug fixes and performance improvements, but you can also profit from the many new features and optimizations Qt 5.12 LTS comes with.

So, the baseline is solid, but 2019 is not going to be merely about bug fixes and polish – we have also many cool new things cooking. Read on for a brief overview of what you can expect to be released during 2019.

Python, WebAssembly and other new goodies

Qt now fully supports Python with Qt 5.12 LTS. A lot of work has been done to get to this point, and we are really pleased to put all of Qt’s functionality at the fingertips of the growing community of Python developers. The work continues throughout 2019 with improvements and new features. In addition to constantly improving the Python bindings and supporting all the new Qt versions and patch releases, we have some great new features planned for 2019.

One highly requested new feature is integration with commonly used Python 3rdparty modules like numpy, pytorch, pandas and matplotlib. Out of these, we expect to provide at least integration to numpy during 2019, possibly some others as well. Easier deployment of Qt for Python applications is another commonly requested item and we aim to provide a better solution in 2019. Other major items include improved integration of QML as well as tooling improvements, especially making Qt Creator an awesome IDE also for Python developers.

Another really cool new item is Qt for WebAssembly. It has so far been a technology preview but will become a fully supported platform with Qt 5.13. It has gained a lot more functionality, as well as performance and stability improvements since the first preview release. We continue to improve functionality and fix bugs as more users adopt Qt for WebAssembly and report issues.

2019 will bring a lot of important features and quality-of-life improvements to Qt for WebAssembly users. Windows will be supported as a development host, in addition to Mac and Linux which were already available. We also start providing binary packages of Qt for WebAssembly, just like we do for most of the other supported platforms. New features coming in 2019 include access to local file systems (with the restrictions imposed by the browser sandbox), threading support on browsers where this is enabled, support for system clipboard, and addressing multiple canvases in the browser document. We are also working to enable debugging and to improve linking times for applications to accelerate development.

With Qt 5.13 we are adding a technology preview of Qt Lottie, a player for Bodymovin animations. Bodymovin is a plugin to Adobe After Effects tool and there are multiple different player implementations on different platforms – and now a cross-platform one created with Qt. The new player allows easy inclusion and use of these animations in a Qt Quick application. Qt Lottie makes it possible to control the pre-created animation (reverse/start/pause/stop/autoplay etc) and even change the animation source dynamically. From the beginning, we have focused on performance aspects to enable Qt Lottie to be used on embedded devices in addition to the typical targets of these animations like web, desktop and mobile platforms.

While the functionality of Qt Widgets is already very comprehensive, we are also planning to add new widgets during 2019. Our current thinking is that a circular progress bar and a switch widget would be good additions. One of them or both should arrive at a computer near you with the Qt 5.14 release. Other than that, we are continuously working to improve Qt Widgets further by fixing bugs and making small improvements where needed.

Tools for Developers: Qt Creator and new Qt Lite Tooling

In the past releases of Qt Creator, we have done a lot of work behind the scenes to switch to the clang code model. Now that this is done, we have already enjoyed some benefits such as clang-tidy and clazy. During 2019 we plan on bringing better diagnostics management as well as improved performance to the Qt Creator IDE. One development item is to use a symbol database (indexdb) to have a fast, binary representation of the project. This is expected to improve performance a lot compared to parsing the files continuously. We are also improving the Language Server Protocol support and leveraging it to support more programming languages with Qt Creator.

The new framework items need good tools and thus we are continuously improving the Python support of Qt Creator to allow great developer experience. Currently just a research item, we might enable the ability to extend Qt Creator via Python in the future. We will update you on where this will lead us towards the latter part of 2019. We are also working to provide out-of-the-box support of Qt for WebAssembly.

CMake has been supported by Qt Creator for quite a while. During 2019, we aim to improve the support further and make it easier to start new projects with CMake. We plan to create a CMake based build system for Qt Creator and to better support embedded development with CMake using Qt Creator.

Qt Quick Designer, which is part of Qt Creator, will receive new functionality initially developed for Qt Design Studio. While Qt Design Studio is indented for designers, not directly as a development tool, it does share a lot of parts with the Qt Creator IDE. Thus, we can bring many of the usability and ergonomics improvements into Qt Creator’s Qt Quick Designer view. One major new feature coming soon to Qt Creator is the capability to create Qt Quick animations using the new timeline editor in Qt Quick Designer.

Qt for Device Creation users will get a major improvement to the Qt Lite configuration tool during 2019. With the new version we are improving the usability of the tool and further extending the configurability of Qt. In addition, we are creating some pre-defined configurations to start from, expected to make it easier to benefit from the tool. One major usability improvement coming with the new version of the Qt Lite configuration tool is capability to directly make the whole configuration with the visual tool, without running separate configure steps.

Tools for Designers: Qt Design Studio and Qt 3D Studio

One of the biggest investments of 2019 will go into the design tooling for both 2D and 3D user interfaces, as well as into further improving the Qt 3D Studio runtime. The long-term goal is to unify the 2D and 3D design tools into one application, of course still having specialized capabilities for 2D and 3D UI. The first steps towards unification are becoming visible during 2019 with multiple shared components, improved interoperability and unified installation of the tools.

Let’s first look into Qt Design Studio, the tool for developing Qt Quick UIs. We published the first release in October 2018. The recently released Qt Design Studio 1.1 provides a lot of polish to the rough edges of the first release, adds merge support for the Photoshop import functionality, as well as brings multiple improvements to the examples and documentation. Also Linux packages are now available in addition to Mac and Windows.

During 2019 we will add many important features to Qt Design Studio, for example support for additional graphics design tools such as Sketch, a new easing curve editor and a new property inspector, both shared with Qt 3D Studio as well. We are also improving multi-monitor support, providing project workspace with dockable windows and finetuning the ergonomics and usability of the application. We aim to make also an open-source release of Qt Design Studio, which is currently only available for commercial license holders.

Qt 3D Studio is getting a major boost in runtime performance with the 2.3 version in March and 2.4 in June 2019. The renewed renderer and animation system as well as support for asset conditioning provide improved performance, significantly reduced CPU load, greatly reduced loading times of the 3D content, as well as lower memory consumption. Throughout 2019, we are making further improvements, allowing complex real-time 3D applications to run well even on mid-tier hardware. For the low-end 3D hardware we recommend leveraging Qt Quick as much as possible and using real-time 3D only for the parts that really need it.

Some of the most interesting new features of Qt 3D Studio coming in 2019 include support for stereoscopic rendering, completely renewed text rendering, distance fields for text, custom vertex shaders and support for precompiled shaders. Qt 3D Studio will also benefit from the new easing curve editor and property inspector, shared with Qt Design Studio. Stereoscopic rendering allows addressing AR/VR use cases easier than before with support for the most common stereoscopic rendering modes. Text rendering of Qt 3D Studio will receive a complete overhaul to be on par with the excellent capabilities Qt Quick offers for text.

With Qt 3D Studio we are also looking into providing an improved integration with content creation tools, such as Autodesk Maya. In addition to tool specific integrations, we aim to improve the already impressive list of supported input formats with new ones such as glTF 2.0 and possibly other new formats during 2019.

Automation, Automotive and other industries

During 2019 we are further developing our offering for safety critical systems. The functional safety certified Qt Safe Renderer will gain the capability to render dynamic text as well as support for large bitmaps. These will allow an even easier creation of complete safety-critical UIs using the Qt Safe Renderer. Furthermore, we are looking into supporting a wider array of hardware as well as possibly running on the simpler real-time operating systems typically available for microcontrollers.

Our offering for Automation and Automotive industries will get some important new features as well. For Automation, we are adding support for the CoAP protocol, first as a technology preview and later as fully supported. In addition, Qt OPCUA becomes fully supported with Qt 5.13 (with some of the new APIs such as QML API still TP) and other automation protocols get a few new features. We also plan to look into Qt OPCUA server implementation, allowing seamless Qt experience also when there is a need to create edge gateway applications.

Qt Automotive Suite will continue to focus on HMI development productivity. This year we aim to improve its capabilities of working with 3rd party service integration and digital assistants, as well as inter-application operation via a new intent API. Through collaboration with Luxoft and KDAB, we will be looking at deep Qt Wayland support with hypervisor composition, and we will work on extending additional out-of-process backends for most automotive use cases For instance separating the UI and vehicle data by leveraging Qt IVI. In addition, we will work on adding useful components such as UI analytics and cursor control. We also continue to address multi-domain use cases by further improving Qt Remote Objects (fully supported with Qt 5.12 LTS) and by improving the graphics sharing functionality.

Work on addressing constantly lower performance (and cheaper price point) hardware continues throughout 2019. Qt is already running on multiple different Cortex-M4 and Cortex-M7 based microcontrollers and widely supported on various low-end ARMv7 and ARMv8 hardware boards. During 2019, we aim to address additional microcontrollers as well as different low-end real-time operating systems for microcontrollers. We are also thinking how to achieve a great developer experience with Qt for microcontrollers. Our long-term goal is to allow development with Qt for microcontrollers to be as easy as any other platform.

Many of the same optimizations and configurability that enables to address the microcontrollers can also be leveraged with the low-end application processors. Qt offers features and functionality not commonly available in the simple frameworks typically used in the low-end devices. With the versatile configuration system, it is possible to choose the needed functionality and leave out the functionality which the application does not require. This allows Qt to fit into a much smaller memory footprint and utilize less system resources than before.

Get Involved

If you want to learn more about upcoming things for Qt, please stay tuned for new blog posts and webinars about the upcoming features, contact our sales teams or join the discussion in the Qt mailing lists and developer forums. We are always delighted to see new contributors in the Qt Project as well as feedback to the pre-releases of Qt via bugreports.

The post Qt Roadmap for 2019 appeared first on Qt Blog.

Qt Creator 4.9 Beta released

We are happy to announce the release of Qt Creator 4.9 Beta!

There are many improvements and fixes included in Qt Creator 4.9. I’ll just mention some highlights in this blog post. Please refer to our change log for a more thorough overview.

Generic Programming Language Support

In Qt Creator 4.8 we introduced experimental support for the language server protocol. This enables editing support for a wide range of programming languages through a common protocol. In 4.9 we add support for the document outline, find usages, and also for code actions, which allow the language server to suggest fixes or refactoring actions at a specified place in the code. If the language server of your favorite programming language supports these features, they are now available in Qt Creator as well. Enable the LanguageClient plugin in Help > About Plugins (Qt Creator > About Plugins on macOS) and configure your server in Tools > Options > Language Client to check it out.

Highlighting is still provided by the generic highlighter in these cases. We changed our highlighter to be based on the KSyntaxHighlighting library, which is the library used in KDE for this purpose. Many thanks to the maintainers of KSyntaxHighlighting for making it available to a wide range of uses.

C++ Support

The UI for diagnostics from the Clang analyzer tools got many improvements. They are grouped by file now. Diagnostics from the project’s headers files are now also included.
Fix-its show details on what they do when applied. We also added a guard against applying Fix-its to files that have changed in the meantime. In the Clazy configuration you can enable or disable individual checks.

If you enabled a diagnostic to be shown inline in the code editor, you can disable individual checks via a button in the diagnostic’s tool tip.

QML Support

We updated our QML parser to Qt 5.12, adding support for ECMAScript 7.

Profiling

Perf is a powerful performance profiling tool for software running on a Linux system. Profile your application via perf with Analyze > Performance Analyzer, after enabling the plugin in Help > About Plugins. The integration in Qt Creator is available for applications running on a local Linux system, and also for applications running on a remote Linux system from a Linux or Windows host.

Generic Projects

Similar to our support for deploying files to a remote system for CMake-based projects, you can now add a QtCreatorDeployment.txt file to your generic project, to specify the necessary information about where to deploy which files.

If your project needs some special compiler flags to be correctly handled by the code model, you can now specify these in a .cxxflags or .cflags file.

Other Improvements

For Windows, we added support for MSVC 2019. On macOS we added a Touch Bar if you run Qt Creator on a MacBook.

For remote Linux targets, we exchanged our Botan-based SSH backend by use of OpenSSH tools. You need to install the tools separately (if you have not already) to be able to benefit from a wide range of encryption and authentication features in Qt Creator. We also added a rsync-based deployment method, as well as support for Run in Terminal.

Version control support has also received many fixes and improvements. The Git Branches view has a new Push action and Git tracks detached HEADs.

Get Qt Creator 4.9 Beta

The opensource version is available on the Qt download page under “Pre-releases”, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.9 Beta is also available under Preview > Qt Creator 4.9.0-beta1 in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

The post Qt Creator 4.9 Beta released appeared first on Qt Blog.

Release 3.1.0: New Felgo Plugins Version, Unified App Configuration and FlickablePage

Felgo 3.1.0 introduces a new Felgo Plugins version and simplifies maintenance with a unified app configuration for Desktop, iOS and Android. The update also adds the new FlickablePage type to the Felgo SDK.

New Version 3 for Felgo Plugins

Along with a full website rebranding and facelift, the previous SDK release 3.0.0 also introduced the new Felgo module for Felgo apps, games and plugins.

Felgo is still compatible with your existing projects, but we recommend to migrate your projects to use Felgo as soon as you can. You can find a full list of the changed modules and components in the Felgo release post.

To match the new Felgo SDK version 3, the version for Felgo Plugins now also increased to 3. This version change is relevant when building your project for the Android platform. You will notice that the configured plugin dependencies in the android/build.gradle of your project are no longer supported.

To correctly integrate the latest Felgo Plugins in your project, please update the build.gradle configuration to use version 3 of the plugins. For example: To use the AdMob Plugin on Android add

compile 'net.vplay.plugins:plugin-admob:3.+'

instead of

compile 'net.vplay.plugins:plugin-admob:2.+'

to the dependencies block of your build.gradle. Note that the version setting at the end of the line changed to 3.+. Please apply this version change for all plugin dependencies in your project. You can also see the updated integration guide in the Felgo Plugins Documentation.

With this change the Android configuration of your app is correctly set up to use the latest version of Felgo Plugins.

Set Product Identifier and Version in Your Project Configuration

The app identifier and version of your app usually require to be specified at many different places. For example at the qml/config.json on Desktop, or the AndroidManifest.xml or Project-Info.plist for mobile platforms.

With this release, you can specify the relevant values with a single configuration for all platforms. The Felgo project configuration now supports the PRODUCT_IDENTIFIER, PRODUCT_VERSION_CODE and PRODUCT_VERSION_NAME settings:

CONFIG += felgo

# configure the identifier and version information
PRODUCT_IDENTIFIER = net.felgo.demos.FelgoProject
PRODUCT_VERSION_NAME = 1.0.0
PRODUCT_VERSION_CODE = 1

New projects created with the Qt Creator wizards use this setup by default. If you want to update your existing projects to this system, also add the relevant placeholders to your Project-Info.plist configuration:

 <key>CFBundleIdentifier</key>
 <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 <key>CFBundleShortVersionString</key>
 <string>${PRODUCT_VERSION_NAME}</string>
 <key>CFBundleVersion</key>
 <string>${PRODUCT_VERSION_CODE}</string>

Otherwise, the project variables are not used on iOS. For Android, you can modify your build.gradle configuration to also use the specified project settings:

android {
    defaultConfig {
      applicationId = productIdentifier
      versionCode = productVersionCode.toInteger()
      versionName = productVersionName
    }
}

For Desktop platforms no additional steps are required. Each time you run qmake for your project, the values are updated with the latest configuration on all platforms.

New FlickablePage Component for Your Apps

Many app pages with custom content require an AppFlickable to make the content scrollable.
To reduce boilerplate code, you can now use the new FlickablePage, which already contains a pre-configured AppFlickable and ScrollIndicator:

flickablepage-control
import Felgo 3.0
import QtQuick 2.0


 App {
   NavigationStack {

     FlickablePage {
       title: "Flickable Page"

       // set contentHeight of flickable to allow scrolling
       flickable.contentHeight: column.height

       // set false to hide the scroll indicator, it is visible by default
       scrollIndicator.visible: true

       // page content
       Column {
         id: column
         width: parent.width

         // fill column with 100 AppText items using Repeater
         Repeater {
           model: 100
           delegate: Rectangle {
             width: parent.width
             height: dp(50)
             AppText {
               anchors.centerIn: parent
               text: qsTr("Item") + " " + index
             }
           }
         }
       } // Column

     } // FlickablePage

   }
 }

All content items of a FlickablePage become children of the internal AppFlickable and are thus scrollable.

Felgo Live Icons on macOS and Linux

It is now easier distinguish the Felgo Live Server and Felgo Live Client on macOS and Linux. The different applications now use different app icons on these systems as well:

felgo-live-server-icons

More Felgo Features and Improvements

The release of Felgo 3.0.0 marks a big milestone and brings many benefits for developers. We have also been working on several bigger additions for Felgo that will be available in the coming months. For example, Felgo Cloud Builds, Web Platform Support, Felgo Cloud IDE or Native App Integration.

For more details how to migrate your projects to Felgo and insights what the Felgo rebranding means for you as a developer, see the Felgo 3.0.0 release post: V-Play is Now Felgo – New Release & Roadmap

For all relevant changes, features and fixes of recent Felgo updates, please check out the changelog.

How to Update Felgo

Test out these new features by following these steps:

  • Open the Felgo SDK Maintenance Tool in your Felgo SDK directory.
  • Choose “Update components” and finish the update process to get this release as described in the Felgo Update Guide.

Update Felgo

If you haven’t installed Felgo yet, you can do so now with the latest installer from here. Now you can explore all of the new features included in this release!

For a full list of improvements and fixes to Felgo in this update, please check out the change log!

 

 

 

More Posts Like This

V-Play is Now Felgo – New Release & Roadmap

The post Release 3.1.0: New Felgo Plugins Version, Unified App Configuration and FlickablePage appeared first on Felgo.

Qt Design Studio 1.1 released

We are happy to announce the release of Qt Design Studio 1.1 !

Qt Design Studio is a UI design and development tool that enables designers and developers to rapidly prototype and develop complex UIs. Both designers and developers use Qt Design Studio and this makes collaboration between the two a lot simpler and more streamlined. To get an impression, you should watch this video.

Since the Qt Design Studio 1.0 release last year we worked hard on bug fixes and new features.

The most notable addition to Qt Design Studio 1.1 is the availability of Linux packages and merging when using the Qt Photoshop Bridge.
To learn more about the improvements and fixes, you can check out the change log.

Qt Design Studio 1.1 is available for Linux

Qt Design Studio 1.1 is available for Linux

This means that developers using Linux e.g. for embedded development can use Qt Design Studio 1.1 directly on their development system.

Qt Photoshop Bridge and updating to Qt Design Studio 1.1

The Qt Photoshop bride allows sanitizing documents

The Qt Photoshop bridge allows sanitizing documents

We updated the Qt Photoshop Bridge for Qt Design Studio 1.1 and we fixed many issues.

Unfortunately, the format for the annotations by the Qt Photoshop Bridge in the PSD and the custom .metainfo file format have changed.

We will try to avoid such breakages in future, but we had to work around some limitations of Photoshop.

PSD files that already contain annotations from the Qt Photoshop Bridge 1.0, require to be sanitized.

Annotations are added whenever you export from a PSD file using the Qt Photoshop Bridge and when you explicitly use the UI of the Qt Photoshop Bridge to annotate a layer.

To remove such annotations you have to use Sanitize document in the Qt Photoshop Bridge.
After doing this you can export the PSD file and use it with Qt Design Studio 1.1.

 

Qt Photoshop Bridge and merging when importing

When re-importing from Photoshop to an existing Qt Design Studio project it is now possible to merge the existing QML files with the newly re-imported QML. This is very useful when the user made changes to the exported .ui.qml files using Design Studio.
Added StatesTimelinesMouseAreasAnchorsAlias Properties or Connections can now be preserved when re-importing from Photoshop and generating the new .ui.qml files.

By default, merging is not active and the importer will simply overwrite the .ui.qml file. You can enable merging using a checkbox in the import dialog.

You can find more information on the Qt Photoshop Bridge in the documentation.

The Photoshop bridge now supports merging when importing into Qt Design Studio

The Photoshop Bridge now supports merging when importing into Qt Design Studio

Update projects from Qt Design Studio 1.0 to Qt Design Studio 1.1

If you have used Qt Design Studio before, you should update projects that you created with the wizards of Qt Design Studio 1.0 since the custom controls like shapes and effects are part of the project.

You have to update the project itself, to get the latest controls and effects.
This is possible by copying the controls from a newly created Qt Design Studio 1.1 project into the existing project from Qt Design Studio 1.0.
The folder you have to replace is “imports/QtQuick”. Replacing this folder will update the Qt Design Studio specific components that are used in your project.

Download and try out Qt Design Studio 1.1

The commercially licensed packages are available on the Qt Account Portal. You can try out and evaluate Qt Design Studio by registering for an evaluation license. We are also working on an open source version of Qt Design Studio and our target is have it out with the 1.2 release (May 2019).

Qt Design Studio 1.1 comes with new examples and updated documentation

Qt Design Studio 1.1 comes with new examples and updated documentation

Getting Started

You can find the latest online documentation for Qt Design Studio 1.1 here. The documentation is also available from inside Qt Design Studio.

The welcome page of Qt Design Studio contains examples and links to video tutorials to help you get started.

Please post issues you find or suggestions you have in our bug tracker.

The post Qt Design Studio 1.1 released appeared first on Qt Blog.

Squish 6.4.3 Maintenance Release Now Available

froglogic GmbH is happy to announce a maintenance release of its flagship product Squish, the preferred tool for creating automated GUI functional regression and system tests for all desktop, mobile, web and embedded platforms. 

Squish 6.4.3 is a patch release containing bug fixes and stability improvements for all editions of the product. The following section highlights a few of the enhancements:

General 

  • Removed unneeded reverse name lookup when attaching to an AUT by IP address, avoiding a 30 second delay when attaching to applications if the reverse name lookup runs into a timeout

Squish IDE

  • Resolved spurious warnings when editing BDD test cases claiming that no matching step definition can be found

macOS (Cocoa/Carbon) Edition

  • Fixed picking of NSButton instances on macOS 10.14 (Mojave)

Qt Edition

  • Added binary packages for Qt 5.12 on desktop platforms (macOS, Linux, Windows)

Web Edition

  • Improved reliability of hooking into Firefox and Chrome

Windows (native) Edition

  • Fixed regression which prevented loading of the UI Automation extension

This release provides a number of other code improvements and bug fixes. The 6.4.3 Release Notes provides a detailed list of all changes. The upcoming product release Squish 6.5 will offer new features for users of all editions, including new developments in Optical Character Recognition (OCR). 

The post Squish 6.4.3 Maintenance Release Now Available appeared first on froglogic.

Cutelyst 2.7.0 released, async is back!

Cutelyst a Qt/C++ Web Framework just got a new version. This time bringing back proper async support.

Perl Catalyst Framework was conceived as a sync/blocking framework, due that the Mojolicious framework was created, NodeJS and a few other web frameworks have pushed the async programming to the web. Performance wise being async doesn't mean you get faster response times, rather the opposite, the need to unroll stack and make extra calls makes a CPU bound application slower.

But depending on the problem to solve it allows you to serve more users at the same time, using the same CPU cores. A typical modern application might receive a request from a Phone App then do a REST API call to an external API which might take 2ms or 200ms for the reply. While waiting for the response, typical sync/blocking applications can't process more requests, or have to spawn more threads increasing RAM consumption and leveraging concurrency to the OS scheduler. On an Async web application, you can process another request while you wait for the previous request, thus possibly making the first request reply to be sent back to the user at a later time than if there was a dedicated process just waiting for his reply.

So, both ways have pros and cons and IMHO I'd like to support them both. When I started Cutelyst I thought that if I ever need async I could have a local QEventLoop to wait for the reply and would be able to deal with async requests, not recently I found out that supporting QEventLoop was causing stack overflow due it being used in pipelined scenarios, after that I removed it's usage and performance improved in PlainText tests of TechEmpower, so I advised against using it and marked Cutelyst as not async.

Recently I got the need to call a few APIs from a REST API I did with Cutelyst, QNeworkAccessManager is an async only API, so either I create a thread for it to mimic sync behavior or allow Cutelyst to be used in async mode, of course I did the latter. The Context class has now detachAsync() and attachAsync() methods.

When you c->detachAsync(), you tell the engine to not send the headers and body immediately to the client, this will also break the action chain, meaning an end() method won't be called, then when you get your async reply you call c->attachAsync().

Once c->attachAsync() is called the action chain is resumed so the end() method that possibly would render the HTML can perform it's job.

It's important to always be child ( QObject->setParent(...) ) of the Context pointer as if the client closes the connection it might be deleted.

This release was not only made of async:

  • A helper UserAgent singleton was added so that you have a thread_local QNetworkAccessManager with static methods to do more common REST tasks like sending a QJsonObject (yes, eventually I find time to write a patch for QNAM)
  • A new Sql::Transaction class gives you a scoped SQL transaction, preventing the mistake of not rolling back when you leave the scope in case of an error.
  • A few Headers helpers like ETag and If-Match comparison
  • Sebastian Held added support for dealing with Front-End Proxy Headers
  • Improved Stats precision using QElapsedTimer::nsecsElapsed()

And finally Cutelyst is not "half modern" CMake anymore, if that can even exist. The include directories of the exported Targets are now properly exported, so that you can remove:

include_directories(
    ${Cutelyst2Qt5_INCLUDE_DIR}
)

Have fun https://github.com/cutelyst/cutelyst/archive/v2.7.0.tar.gz

Scaling Large UI Development Projects and Managing their Complexities with Reference UI: Neptune 3

Complexity kills productivity. The larger a User Interface project scales, the more complex it becomes.

Take an In-Vehicle-Infotainment (IVI) system. The user only gets to interact with the graphic user interface on the screen inside the car. However, the code that connects to the simple and sleek design becomes increasingly complex with every new vehicle model.

To work seamlessly, the IVI needs to be consistent in design and functionality, remaining compatible with the different features of each model at the same time. Essentially this means best practices are necessary, which is what the Qt Automotive Suite provides in the form of Reference UI: Neptune.

Qt Automotive Suite Solution for Development in Complex Environments

Let’s face it: Integrating IVIs seamlessly into a real user interface (UI) is a huge pain. While UI developers are attached to the entire system of the vehicle, we have limited space to work on our component – the user interface – independently. Each action triggers a reaction, and those reactions need to be mapped out. A vehicle isn’t a mere collection of screws and gears anymore, it’s a complex computer system just like any smartphone or laptop.

Larger teams are needed to fulfill the specifications for such IVI system projects. Normally, software teams consist of UI developers and hardware specialists.

In almost every case, UI developers can’t start their work until the hardware teams are done with their part. Without a clear structure, the UI can easily be polluted by unnecessary backend and service dependencies. It is difficult to test each UI component independently without the presence of the backend and services. The hardware needs to sit alongside the UI developer – a clean architecture will help UI developers do their work more efficiently.

The New Architecture of Reference UI: Neptune

Reference UI: Neptune showcases the best practices for developing a scalable automotive UI and as a blueprint for modern digital cockpit development. It introduces a new architecture that allows the UI developer to work without the real target device. With Qt cross-platform capability, UI developers can use their own development platforms such as their own PC or Laptop.

Neptune 3 UI – Center Console

Neptune 3 UI – Center Console

 

Neptune 3 UI – Instrument Cluster

Neptune 3 UI – Instrument Cluster

 

Neptune 3 UI - HUD

Neptune 3 UI – HUD

The new architecture also introduces principles that mean the UI has a clear structure to isolate the dependencies on the backend services. The interfaces are separated from the UI, enabling the developer to test each component of the UI and simulate them. At the same time, the backend or hardware team can use the same API to test their part by simulating the signal that should be accessed from the UI. This way, a clear separation between software and hardware will help developers from both teams to work independently.

Qt Automotive Suite fully integrated into Luxoft Digital Cockpit Reference Platform

Qt Automotive Suite fully integrated into Luxoft Digital Cockpit Reference Platform

Nonetheless, integrated infotainment systems that deliver a number of entertainment and information features to users are becoming more essential in the automotive industry.

Enter the Qt Automotive Suite. It is a collection of software components and tools that enable the development of digital cockpits, including an embedded development environment with additional tools for rapid UI development – as well as application introspection and debugging. Qt Automotive Suite comes with libraries and ready-made components, and also boasts hardware adaptation APIs for creating full-featured IVI solutions.

Isolating the UI From the System: Neptune UI Enables Live-Reloading Development

To truly solve the problems mentioned above, we have introduced a new UI architecture in Neptune UI which decomposes the UI along with its backend dependencies, which are stored separately.

The architecture ensures that UI codes are not polluted by particular dependencies – enabling you to implement the UI Harness in Reference UI: Neptune. With this approach, you are able to isolate part of the UI from the rest of the system, allowing the developer to test every single part of the UI independently. The UI Harnesses also enables live-reloading development, so you see the changes as soon as we implement them – cutting the overall development process significantly.

In short, we can now integrate some simulation backends and get rid of service dependencies. Though some complex structures remain, we’re able to actually work with them. More than that, we can keep our output high, even if the code remains complex. With Reference UI: Neptune, complexity doesn’t kill productivity anymore – it amplifies it.

Read more about

The post Scaling Large UI Development Projects and Managing their Complexities with Reference UI: Neptune 3 appeared first on Qt Blog.

V-Play is Now Felgo – New Release & Roadmap

Today marks a big milestone: V-Play is now called Felgo and got a new facelift. In this article you will learn:

Reasons for Rebranding V-Play to Felgo

The first official version of V-Play was released 2012. We started to work on the first alpha versions in 2009. Back in these days, the main focus area was games. Thus the first APIs were tailored for making cross-platform game development simple and fast to develop.

Interestingly, we saw that many customers used the V-Play APIs and the underlying Qt framework to develop mobile business apps, not only for games. Because many of the APIs we provided were also useful for apps. In addition, a new trend in app development emerged: business apps started to have custom UI and many animations, similar as they are used in games.

This led to a first release of V-Play Apps in 2015. This release contained a specialized set of APIs as part of the V-Play framework to make development easier for software engineers targeting mobile apps, in addition to the already available game APIs. Features like abstracting the different native navigation paradigms of iOS + Android to a single Navigation component, or the native style for Android Material design or Apple Cupertino design made these APIs popular and increased the growth of V-Play developers.
Since this release, the most common question we got was:

“But V-Play is only for games, right?”

The answer to this question is and always has been: NO. It is perfectly suited for mobile app development. And it allows a lot more things like:

  • Develop for desktop platforms with a single code base
  • Develop for embedded & IoT platforms
  • Develop for the web (see the roadmap section below)
  • Cloud services for user authentication, data storage, chat, gamification services and more

In addition, we provide

  • App Development Services to create a mobile app for you or together with your dev team
  • Qt Trainings
  • Qt Consulting services

With such a wide field of use cases and services, the initial name held us back and caused a wrong first impression. This is going to change today.

V-Play is now called Felgo
All products and tools, website content, social pages and dev accounts like our Github page are now called Felgo.

Felgo Logo

What does Felgo mean?

Felgo is an acronym for the 2 V-Play founders names, Christian FELdbacher and Alex LeutGOeb. It is a short & catchy name, easy to type and remember. It allows to become more independent of the actual product and services and provides flexibility for all the new features to come.

What does the Felgo Rebranding Mean for Me as a developer?

Most importantly, all your existing apps work without modification – you do not need to change your existing code after updating to today’s Felgo 3.0 release. New features, however, will only be available with the new Felgo import. The new import makes it easier to develop with Felgo. See the upgrade guide below how to change it.

You can reach the new website on https://felgo.com. All previous links to the v-play.net domain still work and are redirected to this new domain.

The new name allows us to grow even faster than before, because there is no wrong first impression that Felgo is a games-only framework. Felgo is for games, apps, and many more use cases. Accelerated growth means even more features you can expect.

And as a bonus, you will have an easier time telling your co-workers and friends about Felgo and what you can use it for. 🙂

Felgo Roadmap

We have been working on several bigger additions for Felgo that will be available in the coming months. You can expect these new features:

  • Felgo Cloud Build: you will be able to let your app or game build in the cloud, either on our servers or on-premise. You can connect your Git repository or upload a zip file to perform all steps needed in the development process of apps: build, sign, upload for testing or release to the app stores. This service will be available for mobile, Desktop, embedded and Web. It will also allow you to distribute an app to the iOS App store without a Mac, and build for all platforms in parallel.
  • Web Platform Support: You will be able to publish your existing app to the Web with a single code base.
  • Felgo Cloud IDE: Setting up a working development environment for many target platforms can be tricky and time-consuming. With our new cloud-based development IDE, you can develop and even publish any app to all target platforms, without any development setup. You will be able to connect your Git repository and test, debug, and preview your app in the browser, and deploy it to mobile, desktop, embedded and web platforms. Combined with the Cloud Build service, you can distribute your app or build updates from within your browser.
  • Felgo Hot Reload: We have seen great development satisfaction after the Felgo Live Code Reloading feature, which allows you to see changes in your code instantly on all connected devices, for iOS, Android, embedded & Web. With the upcoming Hot Reload feature, you will be able to iterate and develop even faster, because also the state of the app is preserved at a live reload.
  • Native App Integration: it will become a lot easier to integrate native iOS & Android code to your Felgo apps. You will also be able to integrate a Felgo app or single pages easily into an existing native app.
  • Embedded & IoT: We will make development for Raspberry Pi, Arduino, i.MX and other popular embedded platforms easier.

If you’d like to get early access to any of these topics, just contact us.

What’s New in the Felgo 3.0 Release – Upgrade Guide

1. Apps, Games and Plugins Combined in Felgo

You no longer need to use different import statements when working with Felgo. The components of the Felgo Apps, Felgo Games and Felgo Plugins API modules are all available with a single import Felgo 3.0 statement:

import Felgo 3.0
// old:
// import VPlay 2.0
// import VPlayApps 1.0
// import VPlayPlugins 1.0
import QtQuick 2.0

App {

 // Storage, required import VPlay 2.0 before
 Storage {
 }

 // NavigationStack, required import VPlayApps 1.0 before
 NavigationStack {
   Page {
     title: "AdMob Page"

     // AdMob Plugin, required import VPlayPlugins 1.0 before
     AdMobBanner {
       adUnitId: "ca-app-pub-3940256099942544/6300978111" // banner test ad by AdMob
       testDeviceIds: [ "" ]
       banner: AdMobBanner.Smart

       anchors.horizontalCenter: parent.horizontalCenter
       anchors.top: parent.top
     }
   }
 }
}

With many recent additions, the line between the Apps and Games SDK got less clear. For example, the Storage type is also relevant for apps but was part of the V-Play Games module. The SocialView, which is based on app components, replaced the VPlayGameNetworkView also for games, and so on.

You can combine both app and game components in your Felgo app. The unified import for all components now further simplifies this.

Felgo is still compatible with the old V-Play imports. Your existing V-Play projects still work as they used to, without any changes.

But we suggest to update your projects for the Felgo import as soon as you can. The V-Play modules are now deprecated and not maintained further. You can thus only get the latest features and components of future Felgo updates with the new module import.

In case you run into troubles or face an issue after upgrading to Felgo, don’t hesitate to contact us.

2. Improved Component Names

Especially for the Felgo Games module, many components used to have a ‘VPlay’ suffix, which is now removed. This helps to keep component names short and the code is easier to read:

import QtQuick 2.0
import Felgo 3.0

GameWindow {
 activeScene: scene

 Scene {
   id: scene

   // old: SpriteSequenceVPlay
   SpriteSequence {
     id: spriteseq
     defaultSource: "spritesheet.png"

     // old: SpriteVPlay
     Sprite {
       name: "walk"
       frameWidth: 32
       frameHeight: 32
       frameCount: 4
       startFrameColumn: 1
       frameRate: 20
       to: {"jump":0, "walk": 1}
     }

     // old: SpriteVPlay
     Sprite {
       name: "jump"
       frameWidth: 32
       frameHeight: 32
       frameCount: 4
       startFrameColumn: 5
       frameRate: 10
       to: {"walk":1}
     }
   } // SpriteSequence

   Row {
     spacing: dp(4)
     anchors.centerIn: parent

     AppButton {
       text: "walk"
       onClicked: spriteseq.jumpTo("walk")
     }
     AppButton {
       text: "jump"
       onClicked: spriteseq.jumpTo("jump")
     }
   }

 } // Scene
} // GameWindow

Note: Some of the renamed components in the V-Play SDK have colliding names with Qt components. For Example, the Qt Quick module also holds a SpriteSequence or Sprite type. Qt Creator auto-resolves the types with the imported modules in the QML file. At the moment, the most recent import gets precedence to earlier ones. The above example thus uses the Felgo SpriteSequence and Sprite types, because we import Felgo after Qt Quick.

To avoid issues and mix-ups due to this auto-resolve, you can make sure to always use a specific module by setting a custom module identifier for the import. This is how you could use the Qt Quick types in the above example, without changing the order of imported modules:

import QtQuick 2.0 as QtQuick
import Felgo 3.0

GameWindow {
 activeScene: scene

 Scene {
   id: scene

   QtQuick.SpriteSequence {
     // ...

     QtQuick.Sprite {
       // ...
     }
   } // SpriteSequence

 } // Scene
} // GameWindow

This is the full list of components with a removed ‘VPlay’ suffix in their name:

When you update your project to the new Felgo 3.0 import, please also make sure to use the new names for these components if you use them. The name changes only apply for the Felgo module import. Your existing project with V-Play imports is not affected and can still use the old names.

3. Renamed FelgoGameNetwork, FelgoMultiplayer and SocialView

With the rename of V-Play to Felgo, the game network and multiplayer components got renamed as well. The VPlayGameNetwork type is now FelgoGameNetwork, and VPlayMultiplayer turned into FelgoMultiplayer.

As the VPlayGameNetworkView and VPlayMultiplayerView are in the process of getting deprecated, they do not get the Felgo name. These types have ‘VPlay’ removed and are available as GameNetworkView and MultiplayerView. Only the SocialView will see updates and fixes in the future. It is the new default UI for social services and the preferred component to use:

import Felgo 3.0

App {
FelgoGameNetwork {
  id: gameNetwork
  gameId: 285
  secret: "AmazinglySecureGameSecret"
  multiplayerItem: multiplayer
}

FelgoMultiplayer {
  id: multiplayer
  appKey: "dd7f1761-038c-4722-9f94-812d798cecfb"
  pushKey: "a4780578-5aad-4590-acbe-057c232913b5"
  gameNetworkItem: gameNetwork
}

SocialView {
  id: socialView
  gameNetworkItem: gameNetwork
  multiplayerItem: multiplayer
}
}

4. Felgo Project Configuration and FelgoApplication

To integrate the Felgo SDK in your project, set CONFIG += felgo in your *.pro configuration:

# allows to add DEPLOYMENTFOLDERS and links to the Felgo library and QtCreator auto-completion
CONFIG += felgo # old: CONFIG += vplay

# uncomment this line to add the Live Client Module and use live reloading with your custom C++ code
# for the remaining steps to build a custom Live Code Reload app see here: https://felgo.com/custom-code-reload-app/
# CONFIG += felgo-live # old: CONFIG += vplay-live

The previous CONFIG += v-play setting is still supported. For live reloading with custom C++ code, the CONFIG += v-play-live setting changed to CONFIG += felgo-live as well.

If you use Felgo Plugins in your project, link the iOS Plugin Frameworks with the FELGO_PLUGINS configuration:

ios {
   QMAKE_INFO_PLIST = ios/Project-Info.plist
   OTHER_FILES += $$QMAKE_INFO_PLIST
  
   FELGO_PLUGINS += admob # old: VPLAY_PLUGINS += admob
}

In your main.cpp, the Felgo application and Live Client class names also got renamed:

#include <QApplication>
#include <QQmlApplicationEngine>

#include <FelgoApplication> // old: #include <VPApplication>

// uncomment this line to add the Live Client Module and use live reloading with your custom C++ code
//#include <FelgoLiveClient> // old: #include <VPLiveClient>


int main(int argc, char *argv[])
{
 QApplication app(argc, argv);
 FelgoApplication felgo; // old: VPApplication vplay;

 // ...

 // to start your project as Live Client, comment (remove) the lines "felgo.setMainQmlFileName ..." & "engine.load ...", and uncomment the line below
 //FelgoLiveClient client (&engine); // old: VPLiveClient client (&engine);

 return app.exec();
}

Similar to other changes of this update, the previous class names and includes are still supported as well.

5. Deprecated Components

With the power of Felgo Apps at hand, there’s no need to use outdated controls that were part of the Games module. You can take advantage of Felgo Apps Controls and Qt Quick Controls 2 for your games instead.

To make the difference clear and match the name pattern of Felgo app controls like AppButton, those game controls now prepend ‘Game’. In case a ‘VPlay’ suffix was used, it is removed:

Those types are also marked deprecated and won’t receive updates anymore. We advise to not use these types in future projects.

You can read more about the latest changes and previous additions in the change log.

How to Update Felgo

Test out these new features by following these steps:

  • Open the Felgo SDK Maintenance Tool in your Felgo SDK directory.
  • Choose “Update components” and finish the update process to get this release as described in the Felgo Update Guide.

Update Felgo

If you haven’t installed Felgo yet, you can do so now with the latest installer from here. Now you can explore all of the new features included in this release!

For a full list of improvements and fixes to Felgo in this update, please check out the change log!

We are looking forward to exciting times ahead and to many more great apps developed by you, powered by Felgo!

Happy coding.

The post V-Play is Now Felgo – New Release & Roadmap appeared first on Felgo.

Qt on CMake Workshop Summary – Feb ’19

Intro

Last Monday and Tuesday a few brave souls from both the Qt Company and KDAB gathered together in the KDAB Berlin office premises to work on the CMake build system for building Qt. There was Mikhail, Liang, Tobias, Kai, Simon (QtCompany) as well as Jean-Michaël, Albert, Volker and me (KDAB) sitting together in a tight room, focusing solely on the CMake port of Qt.

Excerpt of the top-level CMakeLists.txt in qtbase.git

All work done so far is out in public and can be checked out on Qt Gerrit.

About the CMake port

To put this a bit more into context, the Qt Project believes that building Qt with CMake is our best bet in Qt6 times and thus a group of people have started to build a CMake build system prototype. KDAB has a track record of helping out with the CMake support in Qt. For instance most of the “Modern CMake”-style support in Qt5 has been implemented by Stephen Kelly. As of today, we’re even largely responsible for maintaining the CMake support of Qt5. Since quite a few of our customers are actually heavily invested in CMake themselves, we’d also like to make sure Qt stays easy to use with it in future. Thus we’re continuing to invest in Qt’s CMake support and would like to help out with the early Qt6 build system exploration happening right now.

The central page where we’re currently collecting the progress made as well as the future roadmap is here: https://wiki.qt.io/CMake_Port

On that page you’ll also learn which branch to check out from Gerrit in order to start playing around with the current state of the Qt/CMake build. Please make sure to have the prerequisites for building the branch (i.e. a current CMake build!).

Workshop Summary

As Simon mentioned in his workshop summary, sent to the qt-development mailing list, we were able to make good progress on multiple fronts the last few days. Let me just outline his notes part of that mail, with some additional comments of my own:

Quoting Simon

  • We were able to fix the artifacts of “make install” in qtbase to allow for building an external module (qtsvg) and sample apps. The plan for allowing people to develop apps that work with Qt 5 and Qt 6 is quite simple API wise:
    1. In your application use either find_package(Qt5) or find_package(Qt6)
    2. Always use Qt::Core, Qt::Gui, etc. for linkage
    3. We want to add the “plain” Qt::Core, Qt::Gui, targets also to Qt5’s CMake support
  • The script to converting .pro files to CMakeLists.txt is becoming really good. The goal is to convert all scopes and (source) file names correctly. Right now the repo contains incremental conversions with hand-edits.
  • We’re working on installing the latest CMake (as required) in the provisioning setup, so that we can get a building CI as soon as possible.
  • We were able to verify that cross-compilation works well. The main challenge is ensuring that third-party libraries that used to be copied in src/3rdparty are either installed in the sysroot or can be found outside.
  • We discussed and experimented with different ways of making static builds robust. So static builds themselves work already, but what we’re looking into in particular is an automatic way of propagating Qt internal dependencies (such as double-conversion) correctly, to the build process of the application, that is not fragile.
  • We added a lot more plugins and platform support libraries to the build process and did many improvements to the finding of external libraries.

More than that

  • Additionally we’ve succeeded in generating CMake config files compatible with the current config files generated by the Qt/QMake build
    • For instance, we’ve been able to successfully compile KDAB’s GammaRay (which has a rather complex beast of a CMake build system) against the Qt/CMake build of qtbase
  • We were able to compile QMake using CMake in order to retain the support of using QMake to compile Qt projects for existing users of Qt/QMake

Outlook on the future

  • We’ll investigate ensuring a smooth Qt build process on macOS and Windows platforms for developers
  • We’ll add the CMake build system to other Qt modules (thinking of qtsvg (rather simple), qtdeclarative (rather complex))
  • We’ll add a super build which takes care of building multiple Qt modules in one go (cf. a top-level build off from qt5.git)
  • Test more cross-compilation configurations
  • Make sure static builds of Qt are not a pain to deal with for external users (like it is right now)
  • Make sure to continuously test the Qt/CMake build using basic CI build support.
  • QMake will likely still be around in future Qt6 times, as there’s still a lot of users out there. The difference will just be that QMake itself is built using CMake inside qtbase.git; and QMake’s module .pri files will get generated by CMake instead.
    • Obviously exactly the other way around to what it is right now in Qt5/QMake, where QMake generates the CMake config files for CMake!

If you have comments or if you want to help out, please ideally post feedback on the Qt Project infrastructure. Send a mail to the qt-development mailing list or comment on the wiki page dedicated for the CMake port. Or just join us in the IRC channel #qt-cmake on Freenode!

The post Qt on CMake Workshop Summary – Feb ’19 appeared first on KDAB.

Qt 5.13 Alpha Released

I am happy to inform that Qt 5.13 Alpha is released today. You can download Qt 5.13 Alpha via online installer (both source and prebuild binary packages). Source packages are also available for commercial users in the Qt Account portal and in the download.qt.io for open-source users.

Qt 5.13 New Features page contains information about most important changes coming with the release. Please remember creating the list is still in progress so something important can still be missing. List should be completed by Beta1.

Target is to release Beta1 within coming weeks, when API reviews are concluded. And as with previous releases we will release regular beta n releases until we are ready for RC. Target for Beta1 is 26.2.2019, see whole schedule from Qt 5.13 wiki.

Please take a tour & test Qt 5.13 already now. All feedback is welcome so please give it us feedback by writing to the mailing lists and reporting bugs to Jira.

The post Qt 5.13 Alpha Released appeared first on Qt Blog.