Qt 5.10 brings the new Qt Virtual Keyboard 2.3

The Qt Virtual Keyboard provides you an input framework and reference keyboard frontend for Qt 5 on Linux Desktop/X11, Windows Desktop, and Boot2Qt – embedded target platforms. In addition to a virtual keyboard, the module also offers versatile handwriting recognition with support for multiple different languages.

You can choose among customizable keyboard layouts and styles with dynamic switching, with support for different character sets (Latin, Simplified/Traditional Chinese, Hindi, Japanese, Arabic, Korean, and others) and support for ever increasing number of languages, with possibility to easily extend the language support, preserving the cross-platform functionality.

Some cool features of earlier releases:

  • Left-to-right and right-to-left input.
  • Predictive text input with word selection.
  • Character preview and alternative character view.
  • Automatic capitalization and space insertion.
  • Scalability to different resolutions.
  • Hardware key support for 2-way and 5-way navigation.
  • Audio feedback
  • Handwriting support, with gestures for full screen input.

New features!

With Qt 5.10 comes a new release of Qt Virtual Keyboard: 2.3. With this release we have introduced many new layouts:

  • Bulgarian
  • Czech
  • Croatian
  • Dutch
  • Greek
  • Estonian
  • Hebrew
  • Hungarian
  • Serbian

All languages provided by the Qt Virtual Keyboard will as well be supported with the new handwriting solution, including most Latin languages, also including Cyrillic, Arabic, Chinese, Japanese and Korean.

Here’s a GIF demonstrating the Korean handwriting support and my first attempts at writing Korean:

Korean handwriting support in Qt Virtual Keyboard

Korean handwriting support in Qt Virtual Keyboard

The Japanese keyboard input received several fixes (it no longer crashes when pressing the space after entering a smiley; there were a bunch of small fixes and optimizations).
We also added an InputModeKey to switch between different input modes (e.g. various Asian layouts, numeric, Latin).

Qt Virtual Keyboard is available under GPLv3 open source license and the commercial license from The Qt Company. There is currently choice to use open-source engine for handwriting recognition and word prediction, or a commercial T9 Write solution form Nuance. We are also working with other partners to extend the support for other commercial engines in lated releases of Qt. More info about the related upcoming partnerships is available here.

The new Qt Virtual Keyboard 2.3 is included into the upcoming Qt 5.10 release. Stay tuned to hear more about all the great new additions of Qt 5.10.

The post Qt 5.10 brings the new Qt Virtual Keyboard 2.3 appeared first on Qt Blog.

CPU usage improvements in Qt 3D

Many improvements have been made to Qt 3D since the release of Qt 5.6, our previous long-term-support (LTS) release. Engineers from KDAB and The Qt Company have been working hard to bring new features to Qt 5.9 LTS, many of which are listed in the What’s new in Qt 3D with Qt 5.9 blog post by Sean Harmer from KDAB. While more features are still on the way (such as a Vulkan backend), the focus in the latest releases has shifted towards performance and stability. The performance has in fact improved greatly since Qt 5.6, especially for complex scenes and scenes with large frame graphs.

Scenes with many viewports typically result in large frame graphs because each viewport corresponds to a leaf node. If you are not familiar with the frame graph concept in Qt 3D and how powerful it is, you should check out Paul Lemire’s blog post at kdab.com. The screenshot below is from one of our internal benchmarks; a fairly simple (and colorful) scene with 28 viewports:

Qt 3D benchmark with many viewports

The CPU usage in this benchmark has gone significantly down from Qt 5.6.2 to Qt 5.9.2, and the Qt Company is working together with the engineers in KDAB on a series of changes that we expect will make the CPU usage drop even further in Qt 5.11:

viewport-benchmark-results

Many of the performance improvements have been driven forward by the port of the Qt 3D Studio runtime to be based on Qt 3D. Although the runtime is planned for a release next year, we are already now adding performance improvements to the current Qt 5.9.x LTS series. Here are some benchmark results from our internal Qt3D Studio examples:

3dstudio-benchmark-results

Performance improvements are added in many parts of Qt 3D. We have for instance also added support for efficient file formats, such as glTF2. In this post, we will go into details about some of the changes we are making to reduce the CPU usage, while in a later post, we will discuss reductions in memory consumption.

Improving the job dependency solver

One of the performance improvements we have made was to the Qt 3D job dependency solver. Qt 3D divides work that needs to be done each frame into separate, smaller jobs that can be run in parallel. The jobs are part of the flexible backend/frontend architecture of Qt 3D, which separates the frontend on the main thread from the backend, which consists of aspects that perform the rendering, input handling, and animation (more on this in the Qt 3D Overview docs).

The backend runs jobs from the different aspects on a thread pool, and each job can define dependencies on other jobs that should run before it. These dependencies need to be resolved efficiently, because the jobs often change from one frame to another. While this is simple when the number of jobs is small, it becomes increasingly time-consuming for complex scenes with large frame graphs.

By profiling our examples with Callgrind, we found performance bottlenecks in certain parts of the job dependency solver. Specifically, a large QVector of all dependencies would be resized whenever jobs were finished and corresponding dependencies could be removed from the list. This drastically reduced the performance.

We started working on a solution where we would get rid of the QVector altogether and store two lists on the jobs instead: One list of who the job has dependencies on and one list of who depends on it.

class AspectTaskRunnable {
    // ... other definitions
    QVector m_dependencies;
    QVector m_dependers;
};

With this solution, when a job finished, it could go through its list of m_dependers and remove itself from the depender’s list of m_dependencies. If their list was now empty, that job could also be started. However, we now had many small QVectors that were resized all the time. Although better than resizing a big QVector, it was still not optimal.

Finally, we realized that because the dependencies cannot change while jobs are running, there was no need to track both who depends on a job and who the job is dependent on. For each job, it is enough to know which jobs depend on it, and only the number of jobs it is dependent on.

class AspectTaskRunnable {
    // ... other definitions
    int m_dependencyCount = 0;
    QVector<AspectTaskRunnable*> m_dependers;
};

Whenever a job is finished, we go through the list of jobs depending on it, and subtract their dependency count by one. The latter code looks something like this (shamelessly simplified for readability):

void QThreadPooler::taskFinished(AspectTaskRunnable *job)
{
    const auto &dependers = job->m_dependers;
    for (auto &depender : dependers) {
        depender->m_dependencyCount--;
        if (depender->m_dependencyCount == 0) {
            m_threadPool.start(depender);
        }
    }
}

By implementing this change, the job dependency solver became an insignificant contributor to the CPU usage, and we could start focusing on other bottlenecks.

Improving the performance of QThreadPool

Other parts of Qt are also benefiting from optimization opportunities found in our benchmarks. For instance, Qt 3D uses QThreadPool from Qt Core to automatically manage the jobs and allocate them to different threads. However, similarly to the previous case, QThreadPool used to store jobs in a QVector which would be resized whenever a job was finished. This is not a big issue for use cases with few jobs, but suddenly became a bottleneck for complex Qt 3D scenes with a large number of jobs.

We decided to change the implementation in QThreadPool to use larger “queue pages” and put pointers to these pages in a QVector. In each page, we keep track of the index of the first job in the queue and the index of the last job in the queue:

class QueuePage {
    enum {
        MaxPageSize = 256;
    }; 

    // ... helper functions, etc.

    int m_firstIndex = 0;
    int m_lastIndex = -1;
    QRunnable *m_entries[MaxPageSize];
};

Now, all we have to do is increment the first index whenever a job is finished and increment the last index when a job is added. If there is no more room in the page, we allocate a new one. It’s a simple and low-level implementation, but it’s also way more efficient.

Caching the results of specific jobs

Next, we found that certain jobs stood out as very CPU-demanding. Some of these jobs, such as the QMaterialParameterGathererJob, were doing a lot of work each frame even though the results from previous frames were the same. This was a clear opportunity for caching the results to improve the performance. First, let us have a look at what QMaterialParameterGathererJob does.

In Qt 3D, you can override the values of every parameter defined in a QRenderPass by setting it on the QTechnique, QEffect or QMaterial which is using that render pass. Each parameter is in turn used to define a uniform value in the final shader program. This code shows a QML example where the parameter "color" is set on all levels:

Material {
    parameters: [
        Parameter { name: "color"; value: "red"}
    ]
    effect: Effect {
        parameters: [
            Parameter { name: "color"; value: "blue"}
        ]
        techniques: Technique {
              // ... graphics API filter, filter keys, etc.

              parameters: [
                  Parameter { name: "color"; value: "green"}
              ]
              renderPasses: RenderPass {
                  parameters: [
                      Parameter { name: "color"; value: "purple"}
                  ]
                  shaderProgram: ShaderProgram {
                      // vertex shader code, etc.

                      fragmentShaderCode: "
                          #version 130
                          uniform vec4 color;
                          out vec4 fragColor;
                          void main() {
                              fragColor = color;
                          }
                      "
                  }
              }
          }
    }
}

To figure out the final value of a parameter used in the shader program, QMaterialParameterGathererJob goes through all the materials in a scene and finds the corresponding effects, techniques, and render passes. Then, by prioritizing parameters set in QMaterial over QEffect, QTechnique, and QRenderPass, we determine the final value of the parameter.
In this case, the value is "red", because the QMaterial parameters have the highest priority.

Gathering all parameters is quite time-consuming in large scenes with many materials, and showed up as a bottleneck for some of our Qt 3D Studio examples. We therefore decided to cache the parameter values found by the QMaterialParameterGathererJob, but quickly understood that the cache would always be invalidated if the values changed every frame. This is a common case, especially if parameters are animated. Instead, we decided to cache pointers to QParameter objects rather than their values. The values are then stored outside of the cache, and are fetched only when needed. Caching the results resulted in a huge performance boost in scenes with many parameters, as we only had to run the job when there are larger changes in the scene, such as when materials are added.

We have worked with many cases like this, where we have taken some of our larger examples, profiled them, identified bottlenecks in specific jobs, and worked to find ways to improve the performance or cache the results. Thankfully, the job-based system in Qt 3D makes it easy to optimize or cache specific jobs independently, so you can expect more improvements like this to land in the upcoming Qt 3D releases.

The post CPU usage improvements in Qt 3D appeared first on Qt Blog.

Qt for Device Creation 5.10 Emulator update

controlwindow

The new Emulator 3.0 will address the need to simulate devices with multiple screens. For example, these are present in the dashboards in modern cars.

Multi-screen support

Modern cars have multiple screens on their dashboard. To ease development of applications utilizing multiple screen the emulator has a new multi-screen feature which allows you to emulate devices having multiple screens. In the mockup file, which is now QML based you can declare several displays.

Applications can use one or more screens at the same time.
For every screen your application has to create a separate QQuickView.
for (auto screen : QGuiApplication::screens()) {
auto quickView = new QQuickView();
quickView->setScreen(screen);
quickView->setSource(QUrl("<file.qml>"));
quickView->showFullScreen();
}

Multi-point touch support

Touch and multi-point touch input is supported on all screens. Also the way it works is easier to use.

In multi point touch mode you start by clicking on the screen to add as many touch points as needed.

Starting a left click drag on one of the points will perform a swipe gesture using all of the points while a right click drag will perform a pinch gesture around the average center of all points.

emulator-multiscreen

Plugin Interface

The API for plugins has been simplified. Some parts of the emulator itself are also shipped as plugins as well.
This allows you to provide your own controls in the UI or handle custom communications with a client running inside
the virtual machine.

Mockup is QML

The mockup design done in QML and allows to add sophisticated custom controls more easily. Components like screens and terminals can be handles like regular QML components.

Product information

The Emulator 3.0 is part of Qt for Device Creation within Qt 5.10.

The post Qt for Device Creation 5.10 Emulator update appeared first on Qt Blog.

Qt WebGL: Cinematic Experience

Following the previous blog posts related to the Qt WebGL plug-in development updates, we have some features to show.

As a quick recap: Qt WebGL QPA plug-in is a new platform plug-in which will allow your Qt Quick applications to be streamed and ran directly into the browser using streaming of OpenGL calls and rendered in the client using WebGL. For more info, check the related posts below.

After some months of bug-fixing and other improvements, we managed to accomplish some cool stuff. Take a look at one of our good old demos – Qt Cinematic Experience, running remotely on a TV Web Browser:

In the video, you can see the demo running remotely on the built-in web browser of a usual TV. For the interaction with the application, I’m using the ‘extremely fast’ TV remote which is interpreted as a mouse device. This shows that you can use the WebGL streaming plug-in if your application is targeting a smart-device with a browser to try your applications without creating and deploying the application, this can save a lot of development time.

Remember, you’ll be able to test the plug-in in the upcoming Qt 5.10 release. If you find any bug don’t hesitate to report it.

NOTE: If your application is using Text.NativeRendering and your text is not displayed properly, try removing this option.

The post Qt WebGL: Cinematic Experience appeared first on Qt Blog.

meg@akademy2017

Hi there,

It's been a while since my last post over here. After being drained with a lot of work on the very first edition of QtCon Brasil, we all had to take some rest to recharge our batteries and get ready for some new crazinesses.

This post is a short summary of the talk I presented at Akademy 2017, in the quite sunny Almería in Spain. Akademy is always a fascinating experience and it's actually like being at home, meeting old friends and getting recurrently astonished by all awesomeness coming out of KDE community :).

My talk was about architecting Qt mobile applications (slides here | video here). The talk started with a brief report on our Qt mobile development experiences at IFBa in the last two years and then I explained how we've been using lean QML-based architectures and code generators to leverage the productivity and provide flexible and reusable solutions for Qt mobile applications.

Our approach ‒ named Meg ‒ is defined by two major components: a lean dynamic QML-based architecture for Qt mobile applications and a code generator for enabling the creation of modular RESTful servers and Qt mobile applications. Meg provide a Ruby-based CLI, built on top of Thor CLI framework, with templates specified in ERB (Embedded RuBy). We also designed a nice architecture for the generator itself, so that new templates can be defined as new Thor modules. The framework that implements the lean architecture we designed for Qt mobile applications already provides a JSONListModel QML object, making it easier to implement RESTful Qt clients.

The following templates are currently available:

  • Sinatra RESTful server with modular architecture (sinatra-server)
  • Ruby Sinatra RESTful service plug-in (sinatra-service-plugin)
  • Simple Qt mobile app with plugin-based architecture (simple-app)
  • Qt mobile RESTful app with plugin-based architecture (restful-app)
  • Qt mobile RESTful client plug-in (restful-client-plugin)

You're welcome to try it :) Here is what you need to do:

* git clone https://github.com/sandroandrade/meg.git
* install ruby
* run ‘gem install bundler’
* Run ‘bundle install’
* Meg CLI is available in ‘./bin/meg’

Creating a simple plugin-based QML application

So, these are the steps to create a simple plugin-based QML application using Meg:

1. Create a new project using simple-app as project type (template):
./bin/meg new SimpleApp -t simple-app
2. Create a new plugin, for example, to display students information:
./bin/meg generate plugin students -t basic-plugin -a simpleapp/
3. Create another plugin, for example, to display teachers information:
./bin/meg generate plugin teachers -t basic-plugin -a simpleapp/

In step 1, we create a new project in the simpleapp directory, using the basic-plugin template (-t option). In steps 2 and 3, we create two plugins (students and teachers), using the basic-plugin template and install them at simpleapp directory. After that, your application is available at simpleapp directory and can be built by a normal qmake/make run.

Here is what you get out of those steps:
simpleapp

Creating a Sinatra-based RESTful server

Besides automating the creation of Qt-based mobile clients, Meg also provides some templates for generating RESTful servers based on Sinatra Ruby microframework. As in the client-side, we also designed a plugin-based architecture for the RESTful server, where new services are provided by separate modules. Here are the steps to create a new RESTful server:

1. Create the server project:
./bin/meg new myserver -t sinatra-server
2. Create a plugin for handling CRUD operations for an application for visualizing a conference program:
./bin/meg generate plugin Conference -t sinatra-service-plugin -a myserver/ acronym:string name:string city:string country:string venue:string start_date:datetime end_date:datetime
3. Create a similar plugin for handling CRUD operations for handling speakers:
./bin/meg generate plugin Speaker -t sinatra-service-plugin -a myserver/ name:string affiliation:string shortbio:string

To run the server you first need to setup the database:

$ cd myserver
$ rake db:migrate

And populate some data:

$ sqlite3 db/development.sqlite3
insert into conferences values (1, 'QtCon-BR', 'QtCon Brasil', 'São Paulo', 'Brasil', 'Espaco Fit', '2017-08-18 09:00:00', '2017-08-20 18:00:00');
insert into conferences values (2, 'Akademy', 'Akademy', 'Berlin', 'Germany', 'BCC', '2017-03-01 09:00:00', '2017-03-03 18:00:00');
insert into conferences values (3, 'Conf.KDE.in', 'Conf.KDE.in', 'Guwahati', 'India', 'IIT', '2017-03-10 09:00:00', '2017-03-12 18:00:00');
insert into speakers values (1, 'Our beloved Konqi', 'KDE', 'Konqi is awesome');
insert into speakers values (2, 'Dirk Gently', 'Adams', 'He is a holistic detective');

Now, you can start the server:

$ ruby myserver.rb

Creating a Qt-based RESTful client

Creating a Qt-based RESTful client for our server is also quite simple:

$ ./bin/meg new MyApp -t restful-app
$ ./bin/meg generate plugin conferences -t restful-client-plugin -a myapp -i name -c university acronym:string name:string city:string venue:string start_date:datetime end_date:datetime
$ ./bin/meg generate plugin speakers -t restful-client-plugin -a myapp -i name -c microphone name:string affiliation:string shortbio:string

Such commands create a new Qt mobile project, using the restul-app template. Then, two RESTful client plugins for the aforementioned services are created and installed in the project directory. You can now build your Qt mobile client and, once started the server, this is what you get out from it:

restfullapp

So, that's all folks! We hope this can improve somehow the development workflow and of RESTful-based Qt mobile applications. This is a one-year project being carried out at IFBa by myself and Eliakin Costa. Hopefully, we'll get back with some news soon.

See you!

Qt 5.10 QML Shape testing

When implementing component into QtQuick UI which needs something more than rectangles, images and texts, pure declarative QML hasn't been enough. Popular choices to use for items with some sort of vector drawing are QML Canvas, QQuickPaintedItem or QNanoPainter.

But with Qt 5.10 there will be supports for new Shape element with paths that contain lines, quads, arcs etc. so I decided to install Qt 5.10 beta3 and implement all tests of "qnanopainter_vs_qpainter_demo" with also QML + Shape elements. (This kinda makes it "qnanopainter_vs_qpainter_vs_qmlshape_demo" but not renaming now). So here is in all glory the same UI implemented with QNanoPainter (left), QQuickPaintedItem (center), and QML+Shape (right):


Hard to spot the differences right? If only there would be a way to prove this, some way to x-ray into these UIs... like QSG_VISUALIZE=overdraw to visualize what Qt Quick Scene Graph Renderer sees?


Here you can see that scene graph sees QNanoPainter and QQuickPaintedItem as just big unknown rectangles, while QML+Shape it sees into as that is composed of native scene graph nodes. But proof is in the pudding as they say, what looks the same doesn't perform the same. Here's a video showing all 3 running with two different Android devices:



As different rendering components can be enabled/disabled and settings changed, this demo is quite nice for doing performance comparisons of both exact drawing methods or combining all methods. But those will have to wait for another blog post and for non-beta Qt 5.10 to get fair results. In the mean time, feel free to pull latest sources from github, test yourself and provide patches or comments!

Embracing Modern CMake

I spoke at the ACCU conference in April 2017 on the topic of Embracing Modern CMake. The talk was very well attended and received, but was unfortunately not recorded at the event. In September I gave the talk again at the Dublin C++ User Group, so that it could be recorded for the internet.

The slides are available here. The intention of the talk was to present a ‘gathered opinion’ about what Modern CMake is and how it should be written. I got a lot of input from CMake users on reddit which informed some of the content of the talk.

Much of the information about how to write Modern CMake is available in the CMake documentation, and there are many presentations these days advocating the use of modern patterns and commands, discouraging use of older commands. Two other talks from this year that I’m aware of and which are popular are:

It’s very pleasing to see so many well-received and informative talks about something that I worked so hard on designing (together with Brad King) and implementing so many years ago.

One of the points which I tried to labor a bit in my talk was just how old ‘Modern’ CMake is. I recently was asked in private email about the origin and definition of the term, so I’ll try to reproduce that information here.

I coined the term “Modern CMake” while preparing for Meeting C++ 2013, where I presented on the topic and the developments in CMake in the preceding years. Unfortunately (this happens to me a lot with CMake), the talk was not recorded, but I wrote a blog post with the slides and content. The slides are no longer on the KDAB website, but can be found here. Then already in 2013, the simple example with Qt shows the essence of Modern CMake:


find_package(Qt5Widgets 5.2 REQUIRED)

add_executable(myapp main.cpp)
target_link_libraries(myapp Qt5::Widgets)

Indeed, the first terse attempt at a definition of “Modern CMake” and first public appearance of the term with its current meaning was when I referred to it as approximately “CMake with usage requirements”. That’s when the term gained a capitalized ‘M’ and its current meaning and then started to gain traction.

The first usage I found of “Modern CMake” in private correspondence was March 13 2012 in an email exchange with Alex Neundorf about presenting together on the topic at a KDE conference:

Hi Alex

Are you planning on going to Talinn for Akademy this year? I was thinking about sumitting a talk along the lines of Qt5, KF5, CMake (possibly along the lines of the discussion of ‘modern CMake’ we had before with Clinton, and what KDE CMake files could look like as a result).

I thought maybe we should coordinate so either we don’t submit overlapping proposals, or we can submit a joint talk.

Thanks,

Steve.

The “discussion with Clinton” was probably this thread and the corresponding thread on the cmake mailing list where I started to become involved in what would become Modern CMake over the following years.

The talk was unfortunately not accepted to the conference, but here’s the submission:

Speakers: Stephen Kelly, Alexander Neundorf
Title: CMake in 2012 – Modernizing CMake usage in Qt5 and KDE Frameworks 5
Duration: 45 minutes

KDE Frameworks 5 (KF5) will mark the start of a new chapter in the history of KDE and of the KDE platform. Starting from a desire to make our developments more easy to use by 3rd parties and ‘Qt-only’ developers, the effort to create KF5 is partly one of embracing and extending upstreams to satisfy the needs of the KDE Platform, to enable a broadening of the user base of our technology.

As it is one of our most important upstreams, and as the tool we use to build our software, KDE relies on CMake to provide a high standard of quality and features. Throughout KDE 4 times, KDE has added extensions to CMake which we consider useful to all developers using Qt and C++. To the extent possible, we are adding those features upstream to CMake. Together with those features, we are providing feedback from 6 years of experience with CMake to ensure it continues to deliver an even more awesome build experience for at least the next 6 years. Qt5 and KF5 will work together with CMake in ways that were not possible in KDE 4 times.

The presentation will discuss the various aspects of the KDE buildsystem planned for KF5, both hidden and visible to the developer. These aspects will include the CMake automoc feature, the role of CMake configuration files, and how a target orientated and consistency driven approach could change how CMake will be used in the future.

There is a lot to recognize there in what has since come to pass and become common in Modern CMake usage, in particular the “target orientated and consistency driven approach” which is the core characteristic of Modern CMake.


Upcoming webinars: Sign up Now!

Hi everyone!

Here’s an overview of our free webinars we will be holding in the upcoming weeks. They usually take place at 6pm CET, 1pm EDT and 10am PDT so you can participate live and ask our experts any questions you may have.

Don’t have the time to participate live? Sign up anyway – we will send you a recording and the presentation slides to your email address!

 

8 November: Accelerating time to market for embedded devices
Join our webinar where we’ll go through solutions for tackling the most common issues in executing a large-scale software program. The learnings are mainly based on the extensive experience with embedded customers over the years.

 

16 November: Ask Me Anything about graphics in Qt

In this Ask Me Anything about graphics in Qt, we are putting you in the driving seat. Our smart and handsome graphics specialists, Andy Nichols and Laszlo Agocs will answer your questions live.

 

23 November: Qt or HTML5 – A Million Dollar Question

Burkhard Stubert explains how he could save one of the world’s largest home appliance manufacturers millions of Euros by choosing Qt over HTML. The secret? Qt scales down to lower-end hardware a lot better, without sacrificing user experience.

 

7 December: Pointer Handlers for Fluid Applications in Qt Quick
Over the last few years we have discussed adding a new way in QtQuick to handle events from pointing devices such as touchscreens, mice and graphics tablets. Now it is on track to ship in 5.10. This is an update and demo of the current status.

 

14 December: An Interactive Digital Out-of-Home Software Developed by Using Qt Libraries

This webinar will explore the different features of the interactive DOOH software and underline the integration of the Qt libraries within the software.

 

Missed a webinar such as our hilarious Halloween special? No problem! You can find recordings of all our webinars in the on-demand section! Download them and get smart!

 

The post Upcoming webinars: Sign up Now! appeared first on Qt Blog.

QtWs17: Practical Qt Lite

The Qt World Summit recordings 2017 are online. basysKom presented “Practical Qt Lite”. Qt Lite is a project within Qt geared towards optimizing Qt for smaller devices. One important feature of the overall Qt Lite story is the ability to create size optimized, application specific builds of Qt. These require less flash, less RAM and … Continue reading QtWs17: Practical Qt Lite

Cutelyst 1.10.0 released!

Cutelyst the Qt Web Framework got a new release, another round of bug fixes and this time increased unit testing coverage.

RoleACL plugin is a very useful one, it was written due the need for controlling what users could access, sadly the system I wrote that needed this got unused (although I got my money for this) so this plugin didn't get much attention, partially because it was basically complete.

Then last release I added documentation to it due a user's request and shortly after I found out that it wasn't working at all, even worse it wasn't forbidding users like it should do. So after the fix I moved on writing unit test for many other stuff. There's still missing stuff but overall coverage is much larger now.

Enjoy https://github.com/cutelyst/cutelyst/archive/v1.10.0.tar.gz

FitGraph NG UI prototype

About a month ago I started exercising more, mostly jogging, weights and soccer (with kids). Target is to be in superb shape when 2018 starts, and I'm already feeling stronger & more energetic during the day so looking good!

Anyway, this blog post is somewhat related to that. There's plenty of health-related apps and gadgets available these days and in the past I used some time pondering what would be a perfect activity tracking app for my needs. Now I decided to revive this earlier concept as 'FitGraph NG' while porting it to use QNanoPainter and polishing some parts.

As usual, let's start with a video demonstrating the actual application:



There would of course be more views available, this being just the 'activity timeline' part, but it would already cover many of my initial wishes:
  • Showing the whole day as a graph, data or textually depending on needs.
  • Automatic annotation of activities, type, duration and related activity data. And importantly, being able to select each activity to cover only data during that.
  • See how well you have reached your 'moves' goal which would come from all your activities.
  • Also collect other notes, goals, concerns etc. during the day.
I could write quite a long presentation about this, explain why things are where they are, how interactions are thought out, pinpoint small (but important!) details etc. But don't want to, you can watch the video few times and ponder about those yourself if you wish.

Some more information about the implementation side:
  • Implemented with Qt, so cross-platform on Android, iOS etc. Application logic C++ and UI naturally QML with few shaders.
  • Graphs are painted with single QNanoPainter item for efficiency. Graph animations are driven from QML side for easy tuning.
  • Data is managed with SQLite and fetched into QAbstractListModel. There's configurable QCache to reduce SQL queries. Data in this prototype is generated dummy, but basically allows "unlimited" scrolling of days.
  • Performance was important target, some tricks and optimizations were required to get application working fluidly at 60fps also on lower end Android devices. 
Thoughts welcome and thanks for reading!

Release 2.13.2: Update to Qt 5.9.2 & Qt Creator 4.4.1 | Android Oreo & iOS 11 Fixes & Many Improvements

V-Play 2.13.2 adds support for Qt Creator 4.4.1 and Qt 5.9.2 which fixes Android deployment issues with the latest Android SDK (Android Oreo) and NDK versions and adds support for iOS 11.

It also stores your previous window position and size to accelerate the development process and adds many bug fixes and improvements.

Qt 5.9.2 & Qt Creator 4.4.1 Support

The latest stable Qt and Qt Creator versions provide many bug fixes and improvements. The most relevant change is a fix for building Android projects with ndk r16 and higher and supporting Android tools in Android SDK versions 26.1.1 and higher.

Qt Creator - Qt Quick Designer

Thanks to the internal installation changes we rolled out with V-Play 2.13.0 and 2.13.1, you do not need to manually update the Qt version any longer. Instead, this update will automatically update the Qt version for you for Desktop platforms.

iOS 11 & Android Oreo Support

If you have the Android or iOS platforms installed, please make sure to follow these steps:

  1. Perform the V-Play Update by running the MaintenanceTool in the V-Play SDK directory and select “Update Components”.
    V-Play Update in Maintenance Tool
  2. After the update, open the MaintenanceTool again and Select the “Add or remove components option
    V-Play Installer Windows Add Components
  3. Add the Qt 5.9.2 packages for Android and iOS. This image shows the initial state before you seleced Qt 5.9.2:

    Add the Qt 5.9.2 packages for Android and iOS. iOS is not listed in this screenshot as it is not available on Windows. Unselect the Qt 5.9 package like shown in this image:

  4. In Qt Creator, choose the new kit for Android and iOS based on Qt 5.9.2.

If you are using V-Play Plugins, additionally follow the steps described here. See here how to update your project to support iOS 11.

We will simplify the update process for iOS & Android builds with one of the next updates. So these steps will be done automatically for you just like it is now for Windows, Mac and Linux.

Restore Last Window Position

With this V-Play release, the last window position & size is automatically stored on Desktop platforms (Windows, Mac & Linux) during development when you close your app or game. At the following app start, this last position and width/height settings are then restored.

This accelerates the development process, because you save the time of re-positioning and re-sizing the window to your last setting. This feature is enabled by default for development builds. It is disabled for publish builds – you can enable publish builds by modifying the config.json as explained here. You can also manually enable and disable this new feature with the storeWindowGeometry property.

More Fixes & Improvements

Here is a shortened list of other fixes & improvements in this release:

Besides the highlights mentioned above, there are many other fixes and improvements for the SDK. For a full list of improvements and fixes to V-Play in this update, please check out our change log!

How to Update V-Play

Test out these new features by following these steps:

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

V-Play Update in Maintenance Tool

If you haven’t installed V-Play 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 iOS & Android developers, follow the steps explained above.

 

 

More Posts Like This

How to Make Cross-Platform Mobile Apps with Qt – V-Play Apps

How to Make a Qt app

The post Release 2.13.2: Update to Qt 5.9.2 & Qt Creator 4.4.1 | Android Oreo & iOS 11 Fixes & Many Improvements appeared first on V-Play Engine.

Qt World Summit 2017 Recordings

The Qt World Summit 2017 featured great keynote speakers, #BuiltwithQt customer keynotes and sessions on a wide range of inspiring topics and here are the recordings and the photo gallery from this year’s biggest Qt event made available for easy and fast viewing.

qt-world-summit-event

Qt World Summit sold out this year and for those of you who couldn’t get a ticket, want to re-live the experience or simply could not be at two sessions you were interested in, running simultaneously (quite challenging to do), we have made all the recordings available.

Keynotes

Get inspired by our keynote speakers from this year’s event and watch recordings from:

  • Juha Varelius, CEO of The Qt Company opening the show and providing some insight on why Qt has so much potential and relevance in our everyday life.
  • Lars Knoll, Chief Maintainer of Qt and CTO of The Qt Company discussing the current and next steps of where Qt is going
  • Herb Sutter, Leading C++ authority and chair of the ISO C++ standards committee, talked about recent and relevant topics in the C++ world.
  • Linda Liukas, Programmer, Storyteller and children’s book author who spoke about how we can move towards a more humane tech industry
  • Dr. Steven Goldfarb from the CERN ATLAS experiment who talked about how to answer the most profound questions humanity has
  • Igor Beuker, Entrepreneur & Trendwatcher and his take on the trends in software, how businesses need to switch their mindset and how the “Math Men” are knocking the socks off the “Mad Men” in the world of today’s business.

juha-pic-welcome

#BuiltwithQt Customer Keynotes

Qt is truly everywhere and used in a large variety of industries and use cases. This year’s event featured customer keynotes from leading brands within the gaming industry, consumer electronics, cancer research and automotive customers who all build with Qt. Take a look:

  • Daimler: Behind the scenes of a show car: Rapid UI/UX prototyping and production by Alex Hilliger, Senior Manager Advanced Graphics and rendering
  • Panasonic ITS: The Future of Vehicle HMI Systems by Takayuki Tanabe, CEO, Development Center Chief
  • Hasselblad: Using Qt to Build Next Generation Intuitive High-End Cameras by Richard Röjfors, Senior Developer
  • Quantitative Imaging Systems: The Next Frontier in Battling Cancer by Michel Nederlof, CEO
  • Amazon Lumberyard: Game Engine Evolution: From Tech to UX by Alex Montgomery, Game Engine Tools Specialist
  • Qualcomm:  An Integrated Development Environment (IDE) for Embedded Devices by Justin Howard, Senior Staff

 

takayuki-tanabe-panasonic-its

Sessions & Tracks

Qt World Summit has something for everyone we split all our sessions into tracks. Check out the recordings based on the track that interests you the most:

  • Application Development
  • Embedded
  • Graphics and 3D
  • Technical Deep Dive
  • Automotive
  • Automation
  • Medical
  • Business

With that I hope you will enjoy watching the videos and share the link with your peers!

The post Qt World Summit 2017 Recordings appeared first on Qt Blog.

KDE still makes Qt

A couple of years ago, I made a blog post, KDE makes Qt, with data about which percentage of Qt contributions came from people starting in KDE. Basically, how many Qt contributions are made by people who used KDE as a “gateway” drug into it.

I have now updated the graphs with data until the end of September 2017:

KDE still makes Qt

Many of these changes are made by people not directly as a result of their KDE work, but as a result of their paid work. But this doesn’t change the fact that KDE is an important project for attracting contributors to Qt, and a very good place to find experienced Qt developers.

Qt World Summit 2017 Wrap-up

Two days of Contributors’ Summit, the Qt Training day by KDAB and two days of Qt World Summit!

Over a thousand people, magnificent keynotes, seven tracks of talks spread over two days, twenty sponsors, fabulous evening party, what else could I ask for?

Four glorious days spent amongst the people I feel most at home aside from my real home.

 

First of all I would like to thank the core event team; Maria, Carl, Mira, Anu, Maximilian, Katja and Henri. You guys absolutely rock!

core QtWS team

 

And sponsors, every single of the twenty sponsors deserves a big thank you.

Of course the event does not happen with just the core team, we had close to 50 people from The Qt Company somehow involved in booth duty, track moderation, registration, demo and customer video shooting and the evening party. In addition people to thank include partners for the venue, bcc, event management, build-up, video and still image shooting and the KDE volunteers.

But most of all I would like to thank every single person who attended the event! The event is made by the people. The feeling in bcc over the several days was one of making things happen. A positive vibe in the air, something in the sound that took over the venue on every break.

But before this post turns into an Academy award speech, let’s take a look at some of the moments in the event.

Keynotes!

Seeing the big hall of C01 fill up for the keynotes was a feeling that I will remember for a long time. During the two mornings we had some great keynotes, first our CEO, Juha, gave a good overview of where Qt is and where it is going.

Then Dr. Steven Goldfarb took us to the limits of our knowledge, explaining how we see big and small things. And by the way, did you know that CERN uses quite a lot of Qt in their software development?

After Steven came off the stage, we had the pleasure of introducing Linda Liukas. Our whole core event team were fans of Linda before the event, but her keynote won over everyone I talked to at the event. The energy and heart that she has for teaching kids about computers, logic and programming, is an irresistible combination.

And the short keynotes from major Qt customers, telling how they see the world changing in their respective industries. Daimler, Panasonic ITS, Hasselblad, Quantitative Imaging Systems, Amazon Lumberyard and Qualcomm all told us how they have Qt at the heart of their products.

On the second day we had decided we need a high energy speaker to kick off the day and wake everyone up after the evening party.

Igor Beuker, math man in a world of mad men, got the party started, and gave us a lot to think about.

Igor

The moment many had been waiting for, was when Herb Sutter gave a keynote about some ideas he personally has on the future of C++. “Life is too short to spend it writing abstract base classes”, a sentiment that I completely agree with, not that I have written many abcs lately.

Herb

During the keynotes I was mostly walking between the backstage and the keynote preparation room, and I confess that I missed parts of the talks. Luckily we had the video stream set up in the keynote preparation room, so all the keynote speakers got to see each other’s talks.

Sessions and the show-floor

Aside from the keynotes we had two days packed with presentations ranging from hard core 3D graphics to the business benefits of going with QML rather than other solutions. The idea was to have something for everyone and I think it worked out as it should.

Someone told me that when we two years ago told at the Qt World Summit 2015 that we are going into automotive, they had been wondering about the decision. Now that we this year had the Daimler EQ concept car on the floor and major speakers from the automotive industry, they were quite convinced about the decision and eagerly waiting what will happen in the medical and automation areas in the coming years.

The only bigger issue I saw and heard was that some rooms were too packed with people. I and the people running bigger events know this problem well. With one large keynote hall and multiple smaller rooms, there are bound to be times when some talks draw a large audience and some rooms are less full. We knew that the Application Development track would be an audience magnet, which it was, and placed it in the large hall. However the Technical Deep Dive room was also continuously bursting from the seams. There really is no easy solution for this. We didn’t want to go to the option where people need to pre-register to talks, as planning your day as you go along is something most everyone does.

I didn’t catch many talks, but the glimpses I saw sounded really good! There is a lot of effort in preparing a good talk, and from what I heard, the speakers had done their homework.

I know the thing everyone is asking right now is, when will the talks come online for viewing? Especially the Technical Deep Dive talks, as some people could not get in. Don’t worry, we plan to have the talks available for you really soon. We just need to do some quality checking and then we are good to go.

I already thanked the sponsors, but you can never do that enough. Aside from helping make the event happen, they every year bring cool demos and products for everyone to try out at the event. So thank you to KDAB, e-gits, froglogic, ICS, Luxoft, ISB, mapbox, Intel, basysKom, IncreBuild, Link Motion, Viking Software, Esri, HARMAN, woboq, Toradex, Witekio, Garz & Fricke and sequality!

 

The evening party after the first day was awesome! I have Maximilian to thank for that, great job. Several people told me it was the best evening party at Qt World Summit ever. And I have to agree. Good music, food, drinks, surfing, fussball, a lot of old and new friends and music visuals built with Qt.

Qt Contributors’ Days and Training Day by KDAB

Before the Qt World Summit we had two days of Qt Contributors’ Days, our annual event for anyone who has contributed to Qt. The days gathered about 150 contributors to talk about topics ranging from community activities to technical details in QtCore. I personally like the Contributors’ Days, the feeling is that of old friends coming together to have deeper discussions for two days.

And for the future, the Qt Contributors’ Days are not that technical, there is content that normal experienced Qt  developers can get a lot out of, and also discussions that are not technical at all, but rather about how the community works.

KDAB held the Training day before the Qt World Summit too. In line with the biggest ever Qt World Summit, the training day was the biggest ever too, with 13 trainings running side by side for the day. Something for everyone and a lot of new information for people to take back home after the event.

Final words

I can only talk for myself, but last week was one of the best weeks in my life. On Thursday afternoon I was smiling all the time. Again, thank you to everyone who participated!

I met old friends and made new ones, I think that is the mark of a good event!

Tero // Project manager for Qt World Summit 2017

The post Qt World Summit 2017 Wrap-up appeared first on Qt Blog.

Static binaries (for Go with Docker)

These days Go is quite popular for server based systems (read “cloud”) and one of the nice attributes is that compiling an application results in a single binary with no external dependencies (there is no “runtime” it has to link to). This makes deploying (read “copy to machine”) super easy and is a big contrast to something like Ruby on Rails and its thousands of dependencies. IIRC this feature was attractive to the developers of Qt’s coin (continuous integration agent) as well.

Amusingly in contrast to Rust, Swift or other modern languages the compiler/assembler/linker isn’t powered by LLVM but is based on the Plan9 C compiler which was converted to Go. By setting the GOOS and GOARCH environment variables one can easily cross-compile the binary. E.g. on MacOs build a binary that runs on Linux/ARM64.

When using other system libraries (through cgo) this single binary needs to link to other libraries but this complicates the deployment. The right version and ABI of the library need to be present, if not the application might not start or behaves weirdly. I was in this situation for my tcapflow monitoring utility. I would like to be able to deploy it on any version of RHEL, Ubuntu, Debian without anyone having to install the right libraries.

Here is where musl, Alpine and Docker came to rescue me. Let me briefly elaborate. The dominant C library on GNU/Linux is GNU Libc (glibc) doesn’t support static linking for some good (security, PIE) and some IMHO lazy reasons (PIE could still work, iconv/nss). On the other hand the musl library does support static linking and the C library is quite compatible to glibc and Alpine Linux is a Linux distribution that is using musl instead of glibc. By making use of Alpine I avoid having to build musl and then compiling libpcap and other libraries myself. The final item is Docker. It solves fetching a runnable set of binaries/libraries and setting-up/running a chroot for me. The command line below should result in the alpine container being fetched and an interactive shell prompt coming up. During development I use it to quickly fetch/try the latest version of postgres, mysql, etc.

docker run -it alpine:3.6 /bin/sh

I ended up creating a simple build script that will use the Alpine package manager to install the needed dependencies and then make a static build. The magic for the static build is to pass ldflags to go build which looks like:

go build --ldflags '-linkmode external -extldflags "-static"'

Instead of using a Dockerfile to build a container/image that I will never use (but would still consume disk space) I trigger my compilation through two commands. One to build for i386 and the other for AMD64.

docker run --rm=true -itv $PWD:/mnt alpine:3.6 /mnt/build_static.sh
docker run --rm=true -itv $PWD:/mnt i386/alpine:3.6 /mnt/build_static.sh

In the end I will have two binaries in the out/ directory of my sourcecode. I am using the Binutils objdump to look at the ELF headers of the binary to check which libraries it wants to link to. Shared library dependencies are indicated with NEEDED but in this case there is no such line which means the libpcap dependency was statically linked. For me musl+alpine+docker is the easiest way to build static binaries.

$ objdump -x out/tcapflow-client
out/tcapflow-client:     file format elf32-i386
out/tcapflow-client
architecture: i386, flags 0x00000150:
HAS_SYMS, DYNAMIC, D_PAGED
start address 0x000c55b9

Program Header:
LOAD off 0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**12
filesz 0x004ecf5c memsz 0x004ecf5c flags r-x
LOAD off 0x004edc8c vaddr 0x004eec8c paddr 0x004eec8c align 2**12
filesz 0x0032ea17 memsz 0x0075df34 flags rw-
DYNAMIC off 0x007e2f1c vaddr 0x007e3f1c paddr 0x007e3f1c align 2**2
filesz 0x000000a8 memsz 0x000000a8 flags rw-
NOTE off 0x00000120 vaddr 0x00000120 paddr 0x00000120 align 2**5
filesz 0x00000038 memsz 0x00000038 flags r--
TLS off 0x004edc8c vaddr 0x004eec8c paddr 0x004eec8c align 2**2
filesz 0x00000000 memsz 0x00000004 flags r--
STACK off 0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**4
filesz 0x00000000 memsz 0x00000000 flags rw-
RELRO off 0x004edc8c vaddr 0x004eec8c paddr 0x004eec8c align 2**0
filesz 0x002f5374 memsz 0x002f5374 flags r--

Dynamic Section:
SYMBOLIC 0x00000000
INIT 0x000c54ac
FINI 0x0046eed5
GNU_HASH 0x00000158
STRTAB 0x000001d8
SYMTAB 0x00000188
STRSZ 0x00000021
SYMENT 0x00000010
DEBUG 0x00000000
PLTGOT 0x007e3fc4
REL 0x000001fc
RELSZ 0x000c52b0
RELENT 0x00000008
BIND_NOW 0x00000000
FLAGS_1 0x08000001
RELCOUNT 0x00018a56

Qt Creator 4.5 Beta released

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

There has been very little time between the 4.4 release and the 4.5 feature freeze, but 4.5 still comes with a bunch of very nice improvements.

Locator now does fuzzy camel case matching in the same way as code completion does. Type “c andesu” in locator to open the “AndroidDebugSupport” class.

We started on making the File System navigation pane more useful. It is showing a file system tree now, and you can select the root directory from a list containing the “computer” root, your home directory, your default projects directory, and the base directories of all the projects you have open in Qt Creator. More features are to come in the future.

The configuration UI for CMake projects improved. We added grouping of configuration variables, and the option to change their type, so you can set variables to arbitrary values even if CMake reports the wrong type for them.

For a more complete list of fixes and improvements see our change log.

Get Qt Creator 4.5 Beta

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.5 Beta is also available under Preview > Qt Creator 4.5.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.5 Beta released appeared first on Qt Blog.

Cutelyst 1.9.0 released!

Cutelyst the Qt web framework got a new release. This is a rather small release but has some important fixes so I decided to roll sooner.

The dispatcher logic got 30% faster, parsing URL encoded data is also a bit faster on some cases (using less memory), Context objects can now be instantiated by library users to allow for example getting notifications from SQL databases and be able to forward to Cutelyst actions or Views, pkg-config support has also improved a bit but still misses most modules.

Have fun https://github.com/cutelyst/cutelyst/archive/v1.9.0.tar.gz

Qt 3D Studio Source Code and Pre-Release Snapshots Available

As you may remember we announced in February that we are working on a new 3D design tool called Qt 3D Studio, which is based on a major contribution from NVIDIA. Now we are happy to announce that the code has been pushed into the Qt Project repositories and binary snapshots are available through the Qt online installer.

What is Qt 3D Studio?

  • Qt 3D Studio is a world class 3D User Interface design tool formerly known as NVIDIA Drive Design
  • Cross-platform Qt application supporting Windows, Mac and Linux as development hosts
  • Supports importing design assets from popular authoring tools such as Photoshop, Autodesk Maya and The Foundry MODO
  • Contains an extensive in-built material and effects library
  • Enables rapid prototyping with keyframe animations using the powerful timeline editor
  • Seamlessly integrates with Qt Quick and other modules of the Qt framework
Real-time 3D User interfaces can be easily created with Qt 3D Studio

Real-time 3D User interfaces can be easily created with Qt 3D Studio

 

What has been done in the past 7 months?

Quite some time has passed since the contribution from NVIDIA was received and some may wonder what have we been up to. As the original application was implemented mostly with Windows only MFC we wanted to port it to Qt first before opening the repositories. We have also been cleaning out many of the originally used 3rd party libraries as Qt provides the needed functionality already.

Here are a few items we been working with:

  • User interface has been ported from MFC to Qt so Studio supports also Mac and Linux
  • Look and feel of the application has been slightly updated
  • Qt / QML API has been extended and a new C++ API created
  • Some of the 3rd party components replaced with Qt based implementation to minimize the dependencies and reduce the size of the codebase
  • Changed to Qt build systems and implemented CI integration
  • Analyzing the architecture and benchmarking the in-built rendering to Qt 3D.

Integrating Qt 3D Studio UI’s to Qt applications

One of the areas we have been extending the functionality of the Qt 3D Studio is the integration to Qt and especially to Qt Quick. Now Qt 3D Studio offers easy 2-way integration to Qt Quick:

  • Qt 3D Studio scenes can be easily integrated inside Qt Quick based applications
  • Qt Quick views can be rendered into 3D elements as textures

Working with Qt Creator Designer allows seamless editing of Qt Quick items of the UI

Working with Qt Creator Designer allows seamless editing of Qt Quick items of the UI

In this example the 3D scene contains gauges that have changing content. Gauges have been implemented with 3D Studio which enables use of real time shading and lighting effects. Qt Quick user interfaces (e.g. calendar, music player contacts) are rendered as textures into gauges. Qt Quick application also manages the 3D user interface states changes through the Qt Quick API. 2D parts of the user interface have been designed with Qt Quick Designer.

Roadmap

We are working hard to get the first official release of the new Qt 3D Studio ready by end of November. Multiple pre-release snapshots will be made available and we are interested in receiving bug reports from the pre-releases and perhaps even some code contributions. After the 1.0 release we are planning the make patch releases as needed, and possibly also 1.x feature releases. In May 2018 we are planning to release 2.0 version bringing a new runtime on top of Qt 3D. Applications created with 1.0 are fully compatible with 2.0, just the runtime is changed to allow better portability and other benefits provided by Qt 3D.

Qt 3D Studio Roadmap

Early Access Releases

We have been running an early access program for key customers and selected partners. Working closely with some of the customers has provided us with a valuable feedback on the features and tool usability. We  have also conducted a series of usability tests for finding common problems when users start using the tool for the first time. We have been able to include fixes for some of these findings already into the forthcoming 1.0 release.

1.0  and 1.x releases

First official release is scheduled for the end of November. The whole Qt 3D Studio user interface has been ported to Qt which makes this the first cross-platform release i.e. Windows, Mac and Linux are supported. We have also introduced a remote deployment feature to Qt 3D Studio Viewer which enables automatically seeing design changes live in the target device or for example an Android tablet.

Minor 1.x releases introduce mainly customer requested usability improvements, extended hardware and embedded operating system support and performance improvements.

2.0  release

2.0 Release scheduled in May 2018 will introduce a bigger architectural change where the NVIDIA rendering engine will be replaced with a new rendering engine built on top of Qt 3D. From user perspective this change should not introduce any discontinuity i.e. all projects implemented with Qt 3D Studio 1.0 are working with Studio 2.0 as is. After these changes we have the full ability to implement new features and improvements both on UI level and 3D rendering.

Getting Qt 3D Studio

The post Qt 3D Studio Source Code and Pre-Release Snapshots Available appeared first on Qt Blog.

Watch Live Streams from Qt World Summit 2017: Customer Keynotes from Amazon Lumberyard, Daimler, LG, Qualcomm and More

We are showcasing Customer Use Cases Ranging from Automotive Clusters and IVIs to High-End cameras through to Gaming Tools and Cancer Research at the Largest Annual Event for the Qt Community and we are going to share it with you LIVE

Watch the live streams here

Qt World Summit venue

The Qt World Summit sold out this year and for those of you who couldn’t get a ticket or couldn’t make it for other reasons you can watch the live streaming of the keynotes. We will also publish videos from the sessions in coming days.

Our 14th annual Qt World Summit in Berlin from October 11-12, 2017, featuring customer keynote addresses from leading brands such as Amazon Lumberyard, Daimler, LG, Qualcomm and more. The keynote speakers will focus on a wide variety of highly compelling and relevant topics, including the usage of augmented reality (AR) in autonomous vehicles, how digital image analysis can help in the search for a cure for cancer, and why ease-of-use is one of the main factors driving innovation in the gaming industry.

At Qt World Summit 2017, business leaders, software developers, project managers and other influential members of the Qt global community will discuss the latest trends, market opportunities, technological advancements and customer stories in the Internet of Things (IoT) industry. This year, the Qt Company has gathered customers across industries such as automotive, medical, gaming and more to share Qt’s contributions to their respective initiatives.

In addition to live streaming, videos from talks we will also be filming demos, so stay tuned in our social media channels (Facebook, Twitter, Google+, LinkedIn)  and blog in coming times.

LIVE STREAM TIMES, SPEAKERS AND TOPICS

Wednesday, October 11, 2017

9:30 (CET): “Welcome to The Qt World Summit 2017”, Juha Varelius, CEO The Qt Company

10:00 (CET): “How Do You Measure What You Can’t See?”, Dr Steven Goldfarb, Physicist, ATLAS Experiment CERN

10:45 (CET): “One Hundred Languages”, Linda Liukas, Programmer, storyteller and illustrator

11:30(CET): Daimler, “Behind the scenes of a show car: Rapid UI/UX prototyping and production”, Alex Hilliger, Sr. Manager Advanced Graphics and Rendering

11:40(CET): Panasonic ITS: “Future of Vehicle HMI Systems”, Takayuki Tanabe, CEO, Development Center Chief

11:55(CET): Hasselblad: “Using Qt to Build Next Generation Intuitive High-End Cameras”, Richard Röjfors

12:05(CET): Quantitative Imaging Systems: “Imaging Tissue Architecture: The Next Frontier in Battling Cancer”, Michael Nederlof   

12:15 (CET): Amazon Lumberyard: “Game Engine Evolution: From Tech to UX”, Alex Montgomery, Game Engine Tools Specialist

12:25 (CET): Qualcomm: “An IDE for Embedded Devices”, Justin Howard, Engineer, Senior Staff  

 

Thursday, October 12, 2017

09:15(CET): “Trends in Software and Business”, Igor Beuker, Entrepreneur & Trendwatcher

09:55(CET): “Modern C++”, Herb Sutter, Prominent C++ Expert

10:35(CET):“The Current State and Future of Qt”, Lars Knoll, CTO, The Qt Company and Chief Maintainer, Qt Project

 

With that we hope you will enjoy the live streams!

 

The post Watch Live Streams from Qt World Summit 2017: Customer Keynotes from Amazon Lumberyard, Daimler, LG, Qualcomm and More appeared first on Qt Blog.

Qt World Summit & Open-Source Conference App

The Qt World Summit 2017 will take place in Berlin, Germany from October 10-12. The V-Play team will be in attendance for the world’s largest gathering of Qt developers. Want to meet us there for a chat about cross-platform mobile game or app development? Just let us know when to meet you!

What to Expect at the Qt World Summit 2017?

The Qt World Summit is one of the most important events of the year for cross-platform developers. It gives you the chance to look back over a year’s worth of innovation and get a glimpse at the future of Qt development all in one place.

The World Summit is also the place to be for the best presentations, attending lightning talks and you can rub shoulders with the world’s best Qt developers.

V-Play at the Qt World Summit 2017

The V-Play team will be in Berlin from October 11-12 and the V-Play founders, Christian Feldbacher and Alex Leutgöb, will be holding presentations as well:

Qt in Use in Fortune 500 Companies – Best Practices & Tips for a Faster Time-to-Market
by Alex Leutgöb and Christian Feldbacher will be held on Wednesday, October 11 at 13:55.
See here for more information about this talk’s topics.

App Development with Qt: Technical Tips and Examples for Development & Testing by Christian Feldbacher will take place on Wednesday, October 11 at 16:00.
See here for more details about this talk.

Be sure to drop by and learn the best tips and tricks about cross-platform mobile app and game development with Qt!

Schedule Business Meetings with the Qt World Summit App

To the get the most out of this year’s conference, we developed the official Qt World Summit 2017 conference management app for you! It allows to:

  • Browse the full conference schedule
  • See detailed information for all talks and speakers
  • Manage your personal schedule by adding talks to your favorites
  • Get notified of upcoming favorited sessions with push notifications
  • Scan attendee QR codes and export contacts to your phone or via email
  • Connect with other conference participants, chat and schedule meetings

To get the latest version from the app stores, download the app here:

App Store Google_Play_Badge-1

Get the Open Source Conference App

Best of all, we’ve made this app open-source on Github so you can use it as a starting point for a conference app. Or re-use parts of the code to create your own mobile app.

github_logo

Get the Conference App Source Code on GitHub

cross-platform conference app ios android qt world summit 2017

Contact Us or other Attendees with the Business Meet Feature

After downloading the Qt World Summit 2017 app with one of the links above, you can open the Business Meet page to see all conference attendees who opted in to provide additional infos, like the company name, job role, Qt experience and Qt interest. You can enter these details voluntarily in your Profile Page. You can then send a chat message to the people you’d like to schedule a meeting with, or to the ones you just want to start a conversation with.

business-meet-and-chat

To narrow down your search, you can fine-tune the filters and for example look for people who have chosen “Mobile” as their main Qt interest. Or show the “Qt Newcomers” attending the conference and write a message to those.

You can see all the messages you sent or received in the built-in chat. The chat also allows you to send new messages directly by searching for a user’s name, just like in Facebook Messenger or WhatsApp.
mobile-chat

To get messages in real-time, you receive a push notification to notify you about the new message. If you have the app currently opened, an in-app notification dialog will let you know there’s a new message and you can directly jump to the chat by clicking on this dialog.

Meet Us in Berlin!

You can meet us at the Qt World Summit in Berlin and get all of your V-Play questions answered! Make sure to take advantage of this opportunity to find out the best way to create mobile apps and games in a personal meeting.

The easiest way to get in touch is with the Business Meet Feature of the Qt World Summit 2017 conference app. Just search for V-Play and you can directly get in touch by messaging Alex or Chris!

You can also just use the button below to contact us via email and let us know when you’d like to meet up. Make sure to schedule your meeting soon though as we plan on having a chat with as many people as possible at the summit and the available time slots are limited!

 

If you were lucky enough to get a ticket for the conference, you can also join our technical session for more tips, code snippets and best practices for mobile app development with Qt. We’ll also announce a new feature we’ve been using internally for making the Qt World Summit app faster. Here’s a little teaser about it:

Rapid iOS deployment from Mac, Windows & Linux

 

 

More Posts Like This

How to Make Cross-Platform Mobile Apps with Qt – V-Play Apps

How to Make a Qt app

The post Qt World Summit & Open-Source Conference App appeared first on V-Play Engine.

KDAB, MyScript and Qt Company to create new, non-distractive input method for the Automotive Industry

https://youtu.be/Su2Xxx_fEmo?rel=0&showinfo=0

KDAB will be partnering with MyScript and The Qt Company to incorporate MyScript’s handwriting input technology into the Qt Automotive Suite. This integration will enable multimodal input capabilities using either the existing Qt Virtual Keyboard or a new handwriting input panel powered by MyScript technology.

KDAB's Jan Arne Petersen  demonstrated some of the potential of this integration in his "Using Virtual Keyboards on Qt Embedded Devices" presentation at Qt World Summit 2017.

Volker Krause, Director Automotive at KDAB, said, “MyScript technology offers a highly intuitive user interface and is a great complement to the Qt Automotive framework. We are very excited to partner with MyScript and bring the advantages of multimodal functionality to the automotive cockpit. We look forward to a successful business relationship for the benefit of our mutual partners and customers.”

Read the recent press release...

also on Myscript's website... continue reading

The post KDAB, MyScript and Qt Company to create new, non-distractive input method for the Automotive Industry appeared first on KDAB.

Qt 5.10 Beta Released

I am pleased to announce that Qt 5.10 Beta 1 is now released. Convenient online binary installers are available for trying out features coming in Qt 5.10. We will follow similar Beta process as with Qt 5.9 and provide multiple Beta releases via the online installer. 

For new features coming in Qt 5.10, please check the New features in Qt 5.10 wiki page. A few examples of cool new things coming with Qt 5.10 include new image based styles for Qt Quick Controls, initial support for Vulkan, renewed input handling, new Shape type in Qt Quick, many new languages and handwriting recognition in Qt Virtual Keyboard, support for OAuth 1 & OAuth 2, text to speech functionality and preview of Qt WebGL Streaming Plugin. You may also want to check out our new Qt for Automation offering working in conjunction with Qt 5.10, including new libraries for M2M communication (MQTT and KNX) and more plans for the future (e.g. OPC/UA, DDS).

With Qt 5.9 we slightly adjusted the release process of Qt and same approach will be followed also with Qt 5.10. After the Qt 5.10 Beta 1 released today we will push out multiple new Beta N releases using the online installer. With this approach it is easier than before for users to test the features and provide feedback (via bugreports.qt.io). During the beta phase we expect to have new Beta N releases with 1-2 weeks intervals. When the maturity has increased sufficiently we will create a release candidate of Qt 5.10. These will be made available directly via the online installer, we are not planning publish separate blogs for the subsequent beta releases and release candidate(s). In addition to binaries, source packages of each beta release are of course also available for those who prefer to build themselves.

I hope many of you will install the Qt 5.10 Beta releases, test and provide us your feedback to complete Qt 5.10. For any issues you may find, please submit a detailed bug report to bugreports.qt.io (please remember to mention which beta you found the issue with, check for duplicates and known issues). You are also welcome to join the discussions in the Qt Project mailing listsdeveloper forums and  contribute to Qt.

If you do not yet have the Qt online installer, get it from the Qt Account or from the Qt Download page.

The post Qt 5.10 Beta Released appeared first on Qt Blog.

SDDM v0.16.0

SDDM is a Qt based Display Manager used by multiple desktops, such as Liri, KDE and LXQt. After a little more than one month since v0.15.0, I released SDDM v0.16.0 today. It contains a few bug fixes, translation updates and improvements to the configuration system. Read the release notes and download here.

Clazy Results Visualizer for Qt

Clazy is a clang plugin which extends the compiler with over 50 warnings related to Qt best practices ranging from unneeded memory allocations to API misuse. It's an opensource project spawned by KDAB's R&D efforts for better C++ tooling.

Today, we're proud to announce a Clazy Web UI to view all warnings emitted by Clazy, as well as normal gcc/clang issues.

Furthermore, we'll be hosting it publicly for the Qt code base. This means that you can now head over here and view issues for the dev branch, updated daily:

We have a pretty cool Continuous Integration infrastructure to take care of our customers' code: the CI team is constantly writing new extensions to support all kinds of linters, static checkers, sanitizers and code coverage tools. So when I asked them for a graphical way to view Clazy's results, they jumped on it immediately and agreed it made sense to also run it on Qt.

The usage is self-explanatory, you can click on different Qt modules, then for each module you can expand a warning type and see all source locations where it happens. You can also filter by level: bigger levels can have false-positives, or simply be more noisy or less important.

We also hope to attract new contributors to Qt who wish to start off with simpler tasks. Fixing Clazy warnings is usually easy and might be the incentive users need to surpass the initial barrier of setting up gerrit and learning a new process. After their first commit they'll be more likely to contribute patches for existing bugs.

Contact us if you're interested in generating reports like this for your project.

Update: The results for Qt Creator are now also being generated, here.

[training_callout] continue reading

The post Clazy Results Visualizer for Qt appeared first on KDAB.

Migrate Your Legacy Code to Qt

Companies from various industry domains came to migrate their code built with Qt 3, Qt 4, MFC, Adobe Flash, Motif, HTML5, and many others to Qt 5. We’ve witnessed how the transformation to comprehensive, open architecture software framework can provide a fresh momentum to create opportunities for business growth that wouldn’t otherwise exist.

Benefits of migrating to Qt

There comes a point where further investment in unsupported or suboptimal technology isn’t sustainable anymore. So often legacy applications and UIs are not meeting demands for high performance, portability, and adaptability. Most noteworthy, the high cost of ownership that provided at least somewhat of a return on investment is not anymore aligned with steep growth demands. As a result, the market differentiation that comes with flawless user interfaces can’t be regarded as secondary.

At the same time, we have seen that technology migration projects are sometimes viewed as a major undertaking fraught with risk and uncertainty. Despite the perceived ambiguity towards change, more often than not there could be significantly bigger risks with side-stepping migration. Many businesses are realizing this and those with a clear commitment to change are reaping the rewards.

In brief, there are various benefits of migrating to Qt:

  • Less technical risks
  • Performance boost
  • High flexibility and adaptability
  • Improved maintainability
  • Future proof strategy

Want to migrate to Qt quickly?

The pain of change may not be as great as you think if you go through it with expert help. Experts from The Qt Company and our Service Partners know all the tricks of the trade. This is because they have a clear vision of what your clients and business need. Due to that, they can achieve porting quickly and with appropriate control and risk mitigation.

The set of proven steps to make sure you migrate smoothly

  • Advisory Services: Starting with an in-depth assessment of your current status. As a result, your migration roadmap will be tuned to your unique challenges. Delivery will consist of a comprehensive report accompanied with risk-reward and cost and time estimate for potential migration.
  • Porting Services: With the migration strategies, tools, and techniques in place, it’s time for putting the plan into action.
    • Convert the old structure into the modern model/view architecture
    • Execute migration to Qt with proven roadmap
    • Replace some features with new custom-made components
    • Send back ready-to-ship new application
  • Training Services: Tailored for high impact, we ensure a smooth handover training. With lectures, discussions, examples and hands-on programming labs, your team will learn how to continue to get the most out of Qt.
  • Qt Support Services: First-class support to keep things running. The team works closely with R&D engineers to help developers approach complex technical tasks

Please contact The Qt Company Consulting Services or Qt Service Partners for help in migrating to Qt.

The post Migrate Your Legacy Code to Qt appeared first on Qt Blog.

Qt 5.9.2 Released

I am very happy to announce that Qt 5.9.2 is released today. It contains all the latest bug fixes and improvements from Qt 5.9 branch. Among other improvements, Qt 5.9.2 contains all the bug fixes released with Qt 5.6.3 earlier – and many more. We have also included the new Qt Creator 4.4.1 in the Qt 5.9.2 offline installer packages.

As a patch release Qt 5.9.2 does not add any new functionality, focus is in bug fixes and performance improvements. Compared to Qt 5.9.1, the new Qt 5.9.2 contains close to 300 bug fixes and the total amount of changes since Qt 5.9.1 is over 1000. For details of the most important changes, please check the Change files of Qt 5.9.2.

Our intention is to make frequent patch releases for Qt 5.9 LTS. So if your most desired fix is not included in Qt 5.9.2 there will be more patch releases in the coming months.

If you are using the online installer, Qt 5.9.2 and Qt Creator 4.4.1 can be updated using the maintenance tool. Offline packages are available for commercial users in the Qt Account portal and at the qt.io Download page for open-source users.

The post Qt 5.9.2 Released appeared first on Qt Blog.

Qt Creator 4.4.1 released

We are happy to announce the release of Qt Creator 4.4.1! This release exclusively consists of bug fixes, including but not limited to the following:

Add Existing Files now works again even for the top level project.

We adapted Android support to the changes Google made to the tools in the new Android SDK 26.1.1.

We fixed debugging and QML profiling on QNX targets.

Our packages are based on Qt 5.9.2, which also fixes the issue that menus could open behind the application on Windows.

Get Qt Creator 4.4.1

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.4.1 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.4.1 released appeared first on Qt Blog.

Qt World Summit Conference App – Tech Stack

by Christian Feldbacher, V-Play [Qt Technology Partner] (Qt Blog)

After the Qt World Summit 2017 App Release last week, we will show some of the new features in the latest update and how we developed them. This allows you to use these tips and the source code of the conference app to copy these features in your own apps too.

To get the latest version from the app stores, download them here:

App Store Google_Play_Badge-1

Schedule Business Meetings

In the latest app update, you are able to see all conference attendees who opted in to provide additional infos, like the company name, job role, Qt experience and Qt interest. You can enter these details voluntarily in the new Profile Page. You can then send a chat message to the people you’d like to schedule a meeting with, or to the ones you’d like to start a conversation.
business-meet-and-chat

To narrow down your search, you can fine-tune the filters and for example look for people who have chosen “Mobile” as their main Qt interest. Or show the “Qt Newcomers” attending the conference and write a message to those.

You can see all the messages you sent or received in the built-in chat. The chat also allows you to send new messages directly by searching for a user’s name, just like in Facebook Messenger or WhatsApp.
mobile-chat

To get messages in real-time, you receive a push notification to notify you about the new message. If you have the app currently opened, an in-app notification dialog will let you know there’s a new message and you can directly jump to the chat by clicking on this dialog.

Become Friends :)

The Qt World Summit app further allows you to send friend requests to other users. After your friend request was accepted (this is done via an “Accept” action button in the chat), your new friend will be listed on top of all lists where you can browse users, like in the new chat page or the business meet page. There is also an own top section in the leaderboard that shows your ranking in comparison with your friends.
friendsIn the conference app, you get points for adding talks to your agenda, for opening the app, and when you rate a talk. You can use similar gamification elements in your app too – let’s see how you can add this to your app.

How to use this Social System in Your Apps

We have developed the above features with the V-Play Game Network & V-Play Messagingcomponents. These consist of a backend and a set of client components available in QML. This allows you to easily customize the views, style them to your needs and extend them as you like. To achieve the business meeting feature, we used the customData property that can be stored to a user and set this field if the user decides to share his information on the profile page.

profile-custom-views

In summary all that was needed for the whole featureset explained above was to:

  • Customize the profile page to let the user change his Qt interests.
  • Customize the user row that is shown in the Business meet page and the new chat view to also include the customData.
  • Customize the user row shown on the leaderboard to also include the customData.

Here is an example code how we implemented setting the company name for the customData property of a user in the profile page:

import VPlay 2.0
import VPlayApps 1.0
import QtQuick 2.0

Item { // ProfileView section

  // these are set from the outside
  property VPlayGameNetwork gameNetworkItem
  property GameNetworkUser gameNetworkUser

  GnViewButton {
    text: qsTr("Set Company Name")
    onClicked: {
      NativeDialog.inputText(
        qsTr("What is your company name?"), "",
        qsTr("Your company name"),
        gameNetworkUser.customData["companyName"],
        function(ok, text) {
          if(ok) {
            updateCustomDataField("companyName", text)
          }
      })
    }
  }

  function updateCustomDataField(fieldName, newText) {
    var newUserData = gameNetworkUser.customData
    newUserData[fieldName]= newText
    gameNetworkItem.updateUserCustomData(JSON.stringify(newUserData))
  }

}

The remaining parts are all handled by the client & server components automatically, including:

  • Chat system with push notifications for iOS & Android
  • User search
  • Friend system
  • Leaderboards & Achievements
  • Optional user authorization with Facebook
  • Default views for all the above features
  • Navigation between these views with a navigation stack
  • Support for all platforms supported by Qt, including Mobile, Desktop & Embedded

To add a social system or only parts of it (like the chat) to your new or existing app, see the app’s source code or the documentation for more examples and details. And if you get stuck somewhere, you can ask us for integration help.

QR Attendee Badge Scanning

Usually at conferences, you exchange business cards after talking to someone. After the conference, it is hard to remember when and where you met somebody and what your conversation was about.

To help with this, we added a QR Code Scanning feature to this year’s app. It allows you to simply scan the conference attendee badge with a QR code on it, and all the important information of the guy you have been talking to is stored in the app. The details include the name, email, company name, work address and the phone number (if these were entered at conference registration).

You can then add these contacts to your phone’s address book. Or send all of them as a csv file to yourself via email after the conference, so you can import all contacts in one go to your CRM or to an Excel / Google sheet for further processing.

We used the excellent QZXing library for the actual QR code scanning, which comes with QML components for the ZXing C++ library. You can find the source code how we implemented the scanning in the ContactsScanPage here.

qr-code-scanning-qt

Rate Talks

After a talk is finished, you’ll have the option to rate it 1-5 stars. There will be a follow-up post after the conference to announce the winners. All talks of the conference will be video-recorded and published as well, so the rating results make up for a nice prioritized playlist to watch after the conference.

Feedback Dialog & App Store Rating Dialog

After the user opened the app 5 times, he will be shown a Feedback dialog if he likes or dislikes the app. If he likes it, we show a dialog leading to the app store to rate the app. Getting ratings for an app is very important, because the ratings are a key factor for app store rankings. If he dislikes it, he can still send feedback which helps you to improve your app based on it. You can find the source code of these 3 dialogs in the linked texts.

feedback-dialog-and-app-store-rating-dialog

Cloud Storage & Cross-Platform Data Syncing

Consider this use case: you have an iPad at home and schedule your sessions. However, at the conference you have an Android phone with you. With the WebStorage component, you can store key/value data in a cloud storage. This data is then synced automatically across devices for the same logged in user. If there is a syncing error because the same key was written simultanely, you can choose which of the merge scenarios should be done.

For user authentication across devices, Facebook authentication is supported out of the box, and Email/password authentication is on the way. A nice benefit of the WebStorage and also VPlayGameNetwork is, that you do not need to create an account or connect with Facebook initially: a user is created automatically at the first app start which supports the full functionality.

If you then would like to connect multiple users to synchronize your data (in this case the session schedule) at a later point, you can connect both of your devices with Facebook to start cross-platform and multi-device data syncing.

This is very important for your first app start experience, because there would otherwise be a huge user drop-off if an app requires to create a user account before you see its value.

More Mobile App Best Practices

There are many more best practices like an offline cache for images & for the schedule or push notifications for session reminders. You can find all of these in the app’s source code.

Single Source Code – Native iOS & Android App

Although the Screenshots were created on an iOS device, the app has a native UI & UX on Android as well. On Android, the navigation is different: instead of the bottom tabs, a navigation drawer is used. Also, the page transitions are native ones, you have native scrollbars and list bounce behavior, native fonts, material design, and a lot more details you’ll realize as an Android user.

However, the source code for both iOS & Android is still the same! The V-Play componentsinternally make sure your app will look & feel native on both platforms. We encourage you to download the app on Github, and use the parts useful for your mobile app projects.

cross-platform conference app ios android qt world summit 2017

If you were lucky enough to get a ticket for Qt World Summit (it is sold out as of today!), you can also join our technical session for more tips, code snippets and best practices for mobile app development with Qt. We’ll also announce a new feature we’ve been using internally for making this app faster. Here’s a little teaser about it:

Rapid iOS deployment from Mac, Windows & Linux

See you at the conference, and if you’d like to meet, just send an in-app message with the business meet feature.

:)

The post Qt World Summit Conference App – Tech Stack appeared first on Qt Blog.