We have now released the 1.3.0 version of the Charts which brings Polar and Boxplot charts and some API enhancements. As usual the package is available in the Customer Portal.
Polar chart enables showing data in a circular graph. Polar charts support line, spline, area, and scatter series, and all axis types supported by those series.
Boxplot (also known as box-and-whiskers plot) is a convenient way of illustrating the minimum and maximum values (i.e. the range) with the quartiles. Boxplots have several use cases in statistical analysis e.g. in describing populations or analyzing stock exchange share prices.
With this version of charts we also now provide a Qt Quick 2 support which enables e.g. combining charts to applications created with Qt Quick Controls. However please note that Qt Charts still uses QGraphicsView framework under the hood even with Qt Quick 2. Therefore charts performance is usually better with Qt Quick 1 than with Qt Quick 2.
The Qt Charts 1.3.0 contains also several smaller improvements and fixes which are listed in the README file included in the source package. For an overview of the Charts functionality, please refer to the Charts product page.
We have made the Charts 1.3.0 release available through the Customer Portal. If you don’t have a commercial license for Qt, you can test out the Charts by downloading a 30-day free evaluation. Let us know what you think!
It has been a month since we released Qt 5.1 Beta and I am extremely happy to announce that the Qt 5.1 Release Candidate 1 is now available. Things are looking good for the release of Qt 5.1.0, which we aim to have out in the coming weeks.
For those who have not yet checked what Qt 5.1 brings, please refer to the Qt 5.1. Beta blog post, the wiki article listing key the features, or the documentation snapshot for more details. With the Qt 5.1 RC1 we are also introducing new online installers that initially provide Qt 5.0.2 and Qt 5.1 RC1 content. Later on we will add more releases to be available via the online installers.
The key new items in the RC1 since the Beta are:
Online installers available for Mac, Windows and Linux hosts
Windows 32bit as well as 32bit and 64 bit Linux host support for Android
MinGW toolchain updated to version 4.8.0
32bit VS2012 installer available, and all VS2012 packages built with the SP2 update
Perl dependency removed for building Qt (still remains as requirement for building WebKit)
As well as a large number of fixes done based on the feedback from the Beta.
Please take Qt 5.1 RC1 for a spin and send us feedback:
Both online and offline installers are available for the Qt 5.1 Release Candidate 1, which can be downloaded from the Digia Qt Customer Portal or from download.qt-project.org (online or offline) for open-source users.
We are happy to announce that registration (Berlin only) AND Call for Papers (both locations) for Qt Developer Days 2013 is officially open. Lock down your conference seat in Berlin and register before July 15th to get a free Raspberry Pi. That’s a sweet summer deal.
Registration for our San Francisco event in November will open soon. Stay tuned.
Qt Developer Days 2013 is the 10th annual Qt Developer Days event and together with KDAB and ICS, we are excited to mark a decades-worth of Qt geek fun, networking and top-notch technical presentations.
In order to make sure we have the best possible Qt Developer Days to-date with engaging tracks and sessions, we need your session proposals. If you have the expertise to share your Qt knowledge in any of these areas, please submit a proposal:
Qt on Android
Qt on iOS
Qt on BlackBerry 10
Qt on Sailfish
Qt on WinRT
Qt 3D and OpenGL
Qt Quick / QML
QtWebKit
Qt and C++11
Qt Platform Abstraction (Lighthouse)
Qt product development stories (experiences, process, challenges, differentiation — open source and commercial projects are welcome)
Qt on new hardware platforms (tutorials/introductions, improvements/developments, challenges)
User Experience and Design Guidelines
Development methodologies
Current and possible future Qt components
Qt tools and processes (tutorials/introductions, improvements/developments, tips and tricks, etc.)
Other topics you think are of interest to Qt developers
Learn more about the requirements and submit your proposal here.
This year, we are mixing it up a little bit and introducing a 2-day “Starter Edition” sub-event to Qt Developer Days in Berlin. The Qt Developer Days Starter Edition will run adjacent to the main event targeted at newcomers to Qt who are looking to learn the basics about developing with Qt, learn why to use Qt for application development and get some hand-holding on Qt development best practices. More information on the details of the Starter Edition in Berlin coming soon.
Registration specifically for the Qt Developers Days Starter Edition will open soon. Registration for main Qt Developer Days event in Berlin is now open.
It happens seldomly, but a couple of weeks ago I had the chance to look at some parts of the Windows Runtime port again and now I have some time to write about the outcome.
One of the tedious items when working on the port is that all applications have to be “pre-packaged” to be run on the host system. As this is not really a cross-compile environment, where you need to deploy an application and its dependencies to a device, it feels weird. On the other hand it reflects the real world scenario pretty well, which helps you as an app developer so that you do not forget to put items into the final package.
So right now the test build needs to look like this:
App.exe
AppManifest.XML
QtCore5d.dll
Platform/Imageformat plugins…
…
That implies that you need to copy Qt every time you want to test something. This usually is not a problem for an application developer, who copies Qt once. Doing that while developing on Qt itself is time consuming and error-prone, as for each test application you need to copy again.
Browsing through the documentation I found the following option to be interesting: “Framework ”
Qbs has reached a state where it’s conveniently possible to build projects of the complexity of Qt Creator. Therefore it deserves a version number that reflects its usefulness to the public. To encourage you to use it for your own projects, we hereby present to you qbs 1.0.0.
Why should I use it?
Qbs takes care of your build environment. Build your project for different platforms in the same shell.
Build multiple configurations of your project in parallel.
Fast incremental builds. A speed comparision is here.
QMLish language. Write your complicated tasks in JavaScript instead of some obscure language (I’m looking at you, qmake).
Qbs is supported in Qt Creator 2.8.
Qbs is not tied to the Qt version. That means switching the Qt version doesn’t automatically switch your build tool version.
Where can I get it?
Qt Creator 2.8 will come with qbs integrated.
Instruction how to build qbs from source can be found in the wiki: http://qt-project.org/wiki/qbs
This is a question that arises very often. Though it would be possible to replace the current qmake-based build system of Qt with qbs, we still would need a configure script and our infamous syncqt. I don’t see much gained from that. We’re aiming somewhat higher and want to replace configure and syncqt as well. That’s where qbs still lacks features. Also, bootstrapping qbs is not possible yet.
Today we release the Qt Creator 2.8 beta. Thanks to the 60 individual contributors to this version, it comes with a large amount of new “stuff” and lots and lots of bug fixes.
Too much to cover it all here, as always, so I’ll try to highlight a few things:
You can now open new editor windows with Window > Split New Window. This opens a new window that behaves basically the same as the editor area in the main window (for example you can split this window as well). Opening a document will then open an editor in the last editor window that was active. Since this raises quite some usability questions, how things should work exactly, we want and need your feedback on how you (want to) use that feature, and what issues you have with how it works currently! So please open bug reports, or contact us on the mailing list or IRC when you find something that should work different.
C++ support in Qt Creator got lots of fixes, and more refactoring actions:
Moving function definitions from inline in the header to source
Assigning a method return value or ‘new’ expression to a local variable
Adding declarations and implementations for pure virtual methods from the superclass (many thanks to Lorenz Haas!)
What many of you probably didn’t notice is that Qt Creator 2.7 has an experimental implementation of a side-by-side diff viewer (which needed to be turned on explicitly). This diff viewer is now enabled by default and used for git version control operations. You can also diff two arbitrary files with Tools > Diff.
Git version control integration got many new features, most notably maybe that you now can do interactive rebases from within Qt Creator. But also added was support for updating submodules, continuing and aborting many operations, and a lot more. Thanks to Orgad Shaneh and Petar Perisin for all their work in this area.
Thanks also go to Sergey Shambir who contributed an editor for python code, with highlighting and indentation, and a python class wizard.
Otherwise, display of many data types when debugging with CDB was fixed, QNX and Android support received many fixes, and much, much more. For some more details you can head over to the change log, or just download and try it.
Note: Something that I want to mention here to reduce the surprise: Progress information has moved to the bottom-right corner of Qt Creator’s main window, with the option to hide the detailed progress information and just show a summary progress bar instead.
We have launched Qt Insights, a Qt market research study that will help us learn more about Qt usage in the big world and also help new audiences learn about Qt.
Digia, BlackBerry, Basyskom, ICS and KDAB have come together to sponsor the Qt Insights Market Research Study. Qt Insights will help new audiences learn about Qt through a dialog with Qt users together with a media awareness campaign.
We need your help!
Complete the 10-minute developer survey and enter into a draw to win one of three Blackberry Z10 smartphones plus other prizes courtesy of Digia will be available throughout the campaign.
Take the survey at http://bit.ly/QtInsightsSurvey. Findings will be shared at www.qtinsights.com later in the summer.
For a few months now, we have been working on a new project under the codename Boot to Qt, and today we launch it as a technology preview.
Boot to Qt is a commercial offering that provides a fully integrated solution for the creation of slick user interfaces on embedded devices. The offering includes:
A light-weight UI stack for embedded linux, based on the Qt Framework - Boot to Qt is built on an Android kernel/baselayer and offers an elegant means of developing beautiful and performant embedded devices.
Ready-made images – We have images for several different devices which include the Boot to Qt software stack, making it possible to get up and running with minimal effort from day one.
Full Qt Creator Integration – One-click deploy and run on hardware and a fully featured development environment.
Simulator – A VirtualBox based simulator which allows device development without hardware and opens up for simulating hardware input, such as GPS and connectivity.
This technology preview focuses on the stack built on an Android baselayer. We also want to provide a similar software stack and the same convenience with ready-made images and IDE integration also for traditional embedded Linux, hopefully with a preview coming some time this summer.
We are expecting to have an official release towards the end of this year.
The following video shows Boot to Qt in action on our reference hardware:
And the following video show the Boot to Qt SDK works:
Scope of Boot to Qt
The software stack includes most of the Qt Framework:
Qt Core, Qt Gui, Qt Network, Qt Widgets, Qt Xml
Qt QML and Qt Quick
Qt Quick Controls
Qt Graphical Effects
Boot to Qt specific additions, including virtual keyboard, brightness control and power off/reboot functionality
The hardware devices supported in the Technology Preview are:
Google Nexus 7 - 1.2 GHz Quad-Core ARM Cortex A9, Tegra 3 GPU, 1GB RAM
This is not a fixed set, but a place for us to start. If you have suggestions for other devices, let us know. The stack can also run on x86 hardware.
Right now, the stack is single-process. The launcher is a QML application which launches other QML applications in-process. We have looked briefly into using Android Gralloc APIs to do multiprocess sharing of hardware buffers, and we know it can be done, but we consider this out of the 1.0 scope.
We have also had similar discussions around Multimedia and Webkit, we want to have them in place, but maybe not in the initial release. The current software stack is already quite powerful and serves a number of different use cases.
Performance
Qt 5 introduced a new OpenGL ES 2.0 based scene graph to power Qt Quick 2. This makes Qt Quick very suitable for running on embedded hardware, even those with moderate specs. The demo launcher we ship with the images for instance, runs velvet at 60 FPS on all our hardware devices.
We were looking at CPU usage while playing around in the application launcher on the Nexus 7. When idle, it uses a shader to add a glow on the currently selected item and has a small particle system on the Qt logo in the corner. We found that when the launcher was just animating the glow on the active item and running the small particle system on the Qt logo, the CPU load was running at about 50%. When we flicked it, it dropped to 30% and when the finger was down and we were moving the list via touch, it dropped to below 20%. So it seemed that the more we did, the less the CPU load became. What we were observing was CPU frequency scaling. The CPU is a Quad-core clocked at 1.2GHz (with a special 1.3Ghz single-core operating mode), but when idle, it had disabled 3 cores and had scaled the one remaining core to 102Mhz. So we were able to animate a large part of a 1280×800 screen at 60FPS on a CPU clocked at 102Mhz, and were still only using half of that.
For reference, the same animation runs at 2% CPU on the i.MX6 and 15% on the Beagle, none of which does do frequency scaling.
We also have pretty decent startup times. Below is a diagram comparing Boot to Qt to native Android. Now of course, full Android brings in a lot of additional stuff, but that is also the point. Most embedded devices do not need that.
Startup times, in seconds, from power-on until device reaches the B2Qt launcher or the Android Homescreen.
Lower is better
This is not too shabby, but we believe we can cut this down a bit more, at least when we start exploring various embedded Linux configurations. As an example, Qt 5 on Raspberry Pi can start rendering after as little as 3 seconds.
Boot to Qt is available for evaluation upon request. If you want to try it out or if you are just interested in the software, please use the contact form on the product page and we will be happy to get you started. Of course, feel free to leave comments and questions on this blog too.
Digia has supported Metropolia University of Applied Sciences in their electric car project called Electric Raceabout (E-RA). This cool research project has produced a street legal electric sports car, which not only has the World record on ice, but also runs Qt.
Metropolia University, located in Helsinki, Finland, does extensive research on electric vehicles, one example being E-RA – an electric sports car built primarily by automotive engineering students.
With 4-wheel drive and well designed handling E-RA is a really capable sports car with impressive specs:
Top speed of over 260 km/h
Motor power of 282 kW
Peak torque of 800 Nm – in each wheel
And all this provided by an electric vehicle that is fully street legal (and rest assured, the Finnish road inspection is surely one of the toughest in the world to pass).
E-RA has achieved lap time of 8 minutes 42,72 seconds at Nürburgring Nordschleife, which was electric vehicle track record for quite a while, as well as World record as the fastest electric vehicle on ice with average speed of 252,09 km/h. Nicely driven E-RA has operating range of over 200 kilometers.
The students have built both the IVI system and the instrument cluster with Qt 4.8 running on top of Linux. I think the whole E-RA project is a really great proof of the skills the soon-to-graduate engineers have, and certainly the Qt parts are no less impressive.
Have a look on the enclosed video produced by the students at Metropolia University to hear the full story:
If you want to create a QML application where the UI responds well to window resizing, the toolbox that Qt Quick offers has been somewhat limited. Qt 5.1 will offer the new Qt Quick types RowLayout, ColumnLayout and GridLayout for this purpose.
Background
Up until Qt 5.1, positioners and anchors have been the only Qt Quick tools available for arranging items in the UI.
Positioners are convenient for adding many items, but not always helpful for creating a resizable UI since they (as the name implies – surprise, surprise) only positions the items – the widths and heights are kept the same.
Anchors allows a bit more flexibility, at the price of verbosity. With anchors you can make an item stretch by binding one edge to the corresponding edge of the parent, and you set up a similar binding on the items’ opposite edge. However, you cannot make several items distribute themselves evenly if the window is resized.
The last option is to do the manual layouting yourself. This offers great flexibility, but it can be verbose, cumbersome and error-prone. During the development of Qt Quick Controls, we wanted to improve this and decided to provide a better and more convenient layout system.
import QtQuick.Layouts 1.0
By including the above import you will have RowLayout, ColumnLayout and GridLayout available in your toolbox. These layouts behave very much like their sisters found in the QtWidgets module: QHBoxLayout, QVBoxLayout and QGridLayout. It also tries to match the API of the Row, Grid and Column QML elements where it makes sense. So, if you are familiar with any of these APIs, you will find Qt Quick Layouts easy to grasp.
Alignment of items inside a cell can be specified with the Layout.alignment property.
The feature set it adds might not look like a lot, but the fact that you can have both non-stretching items and stretching items in the same layout makes things easier and more intuitive in many cases.
Example
Suppose we need to create a ToolBar with two buttons and a slider that occupies the remaining space. When resizing, the extra space will be allocated to the slider.
Without Qt Quick Layouts, the solution with least code would probably be a mix between using a Row and using anchors:
Notice how much shorter the declaration for the Slider element is. Also note that when using Qt Quick Layouts, the spacing only needs to be specified once. Code is reduced from 288 to 172 characters (whitespace excluded), which is a 40% reduction.
Summary
In this example, by using Qt Quick Layouts we got 40% less code, improved readability (not only because the code got shorter, but also because the structure of the code became closer to the structure of the UI).
If you want a resizable UI, you will probably find that Qt Quick Layouts are easier to use than anchors, positioners and manual layouting.
The Qt Blog provides you with one area for all Qt development posts from our Qt engineering experts. It includes information on projects in the works, tips and tricks, technical release information and more from our pool of very clever Qt developers.
