Three Steps to a Successful Embedded Product

Developing an embedded product requires three main steps: selection of the proper hardware platform, operating system selection/setup, and User Interface (UI) development.  All three of these steps are very closely tied together and have a significant impact on time-to-market, project costs, and the overall quality of the product.  It is critical to select the proper hardware platform that also has excellent operating system support as well as the proper UI tools. This post dives into each of these steps and how it will impact the overall project.

1. Choose Your Hardware Platform

Selecting the proper hardware platform is the first step in the embedded product process and can have a substantial effect on the overall costs of the project in terms of unit cost as well as development time. Some important questions to ask in the selection process are:

• Is there a stable supply chain/guaranteed longevity/availability? If the hardware that is selected is no longer available in 6 months, all of the development time will be wasted causing substantial delays in the project and significant cost.
• Is it a high quality product? Many designs are not done with best practices in mind which can cause severe headaches in the future due to device failures. Having to recall products tarnishes the brand and has a very high cost associated with replacement.
• Is there flexibility to provide easy upgrade paths that reduce development time/cost for future revisions?

A variety of integration options are available including Single Board Computers (SBC), System-on-Modules (SOM) and custom designs.

The SBC option is typically a fully completed design that requires a display and power supply. SBCs can be pre-FCC certified meaning that users do not need to worry about certification issues. Some SBC options can be cost-reduced by de-populating components that are not required in production.

Nitrogen6_MAX: High-end Embedded single board computer based on the NXP/Freescale i.MX6 Quad Processor. Kit includes 5V Power Supply, 4GB microSD card with Linux OS, and Serial Console Cable.

The System-on-Module provides flexibility for those who have specific IP or circuitry that they would like to include on their carrier board. The SOM contains the CPU, memory, flash, and power supplies. The rest of the circuitry is designed into the carrier board.

The final hardware option is to hire a specialist company to design a semi-custom board to meet the exact specifications of the project. In production, these solutions will be the lowest cost option because they are designed for exactly what the project requires.

2. Select a Trusted Operating System

Having a stable, high quality operating system reduces development time and helps to get to market quicker. A poor quality operating system can waste software resources due to time spent fixing bugs and also creates potential product reliability issues in the future. Selecting from industry leading operating system options such as Android 5.0, Yocto, Ubuntu, QNX, CE7/CE2013, and Buildroot will reduce the risk of these issues.

3. Create Your UI

The third and final piece of the puzzle is the user interface. One of the most complex and time-consuming elements of an embedded project is the UI development.  By utilizing a known, tested UI development tool, embedded products statistically get completed faster, which accelerates time-to-market and reduces development costs.

On hardware (such as that from Boundary Devices) that supports Qt for Device Creation, it is possible to download the IDE and start developing within minutes.

To sum it all up…

When embarking on a new embedded project, take care to select proven hardware platforms and operating systems and make sure that your partners have the experience and capabilities to see you through the entire project. Having a close association with Qt will almost certainly give them (and you) a head start. As a Qt Technology Partner, Boundary Devices can offer you exactly that.

You can contact me here:  pejman@boundarydevices.com

About the Guest Blogger: Pejman is a partner at Boundary Devices and has been involved in hundreds of embedded projects – from design to manufacturing to software support.

The post Three Steps to a Successful Embedded Product appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1UERp4j

Qt Creator 4.0 Beta released

We are happy to announce the release of Qt Creator 4.0 Beta.

As announced earlier this year, starting with this release Qt Creator will be available under commercial license terms and GLPv3 (with exceptions). At the same time we are making the following features available under open source, which were previously only available under commercial license terms. So, if you didn’t know them, make sure to check them out!

Clang Static Analyzer Integration

Find problems in C, C++ and Objective-C programs. (Documentation)

Autotest Integration (Experimental)

Easily run autotests from your project and get the results presented in a friendly way. (Documentation)

Extended QML Profiler

Profile pixmap cache usage, scene graph performance, JavaScript memory usage and input events of QML applications. (Documentation)

 

We also started implementing a flat theme for which Diana presented the concepts already a year ago. This is still work in progress, but you can see for yourself by switching to the new theme “Default Flat” in Tools > Options > Environment > Interface.

Users of CMake will find that we improved the workflow for CMake-based projects. CMake is now triggered automatically when necessary, which makes for a much nicer user experience. Kit settings like the Qt version or tool chain used are automatically configured in CMake build directories, removing one more obstacle for users. Projects mode now features a UI to change the CMake configuration for a build directory. Qt Creator will no longer create CMake build directories before the project is built. This makes for a much tidier work environment, especially when users only want to study source code using the CMake build system.

If you wonder where Analyze mode has gone: It is now merged into Debug mode. There is not much of a difference really. Merging them removes complexity code-wise and user-interface-wise, and it actually opens up some flexibility for us for the future.

There were many more improvements, and more features added, please check our change log for details.

You find the opensource version on the Qt download page, and commercially licensed packages on the Qt Account Portal. 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.0 Beta released appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1RjLAVN

Qt 5.6 released

I’m happy to announce that Qt 5.6.0 has been released today! This release has taken a bit longer to finish than we originally expected, mostly because we put a lot of new infrastructure in place, allowing us to make Qt 5.6 a Long Term Supported (LTS) release. With that, Qt 5.6 (LTS) will be receiving patch releases with security updates and bug fixes for the next three years, in parallel to upcoming Qt versions. Today, with Qt 5.6, we’ve now also made our new offering for start-ups and small businesses available!

Long-term support

The last release that was supported for a long period of time has been Qt 4.8. Since we are ending the support for Qt 4.8, there is a need to have a new version of Qt that will be supported for a longer period of time.

With Qt 5.6, we feel comfortable offering this long-term commitment. We have had a tremendous amount of changes and improvements since the initial release of Qt 5, making Qt 5.6 a very good and solid basis to base your projects on.

As part of the LTS promise, we will be supporting Qt 5.6 for the coming three years, keeping it updated with regular patch level releases and bug fixes.

With Qt 5.6 being supported for a long period of time, we at the same time gain some more freedom in the upcoming versions of Qt. As such, Qt 5.6 will also be the last release that will work without requiring a C++11 compliant compiler. With Qt 5.7, we will also be dropping support for some older platforms.

For more information about our LTS promise, please have a look at the related blog post.

Infrastructure work

With Qt 5.6, we have been working a lot on the infrastructure that supports our development and releasing. The new continuous integration system (named COIN) is a project that we started around a year ago to overcome many issues we had experienced with the old Jenkins-based CI and releasing system. The new system is a lot faster in integrating and testing new changes that are supposed to become part of Qt. It also works much more incrementally, making it easier to bring all the repositories and source code that is part of a Qt release together.

We are now also producing most of the release binaries within the same system ensuring that COIN tests exactly the same configurations of Qt that are provided with the release packages, also cutting down significantly on our package generation time.

Another big advantage with the new system is that we can now efficiently support different configurations and platforms for different Qt branches; a big enabler that we had to have in place for making Qt 5.6 a long-term supported release.

Windows

While Qt 5.5 was mostly working on Windows 10, Windows 10 is now fully supported with Qt 5.6, both using the old win32 and the new WinRT APIs. Qt Applications can run on desktop PC’s, tablets and phones and of course be distributed through the Windows Store. Bringing your existing Qt-based application into the Windows Store should in most cases simply be a matter of recompiling it against the WinRT version of Qt.

With Qt 5.6, we are in addition providing binary packages for the Visual Studio 2015 compiler. Unfortunately, the Visual Studio add-in does not work anymore with Visual Studio 2015, as Microsoft changed their plugin infrastructure, but we are providing an updated version of the plugin for older Visual Studio versions. We’ve also started working towards creating a new Qt integration for the Visual Studio 2015 IDE.

For embedded Windows devices, Qt 5.6 adds support for Windows Embedded Compact 2013 in addition to the existing support for Windows Embedded Compact 7.

High-DPI support

A lot of changes went into Qt 5.6 that ensure that Qt works better on high resolution screens, on all platforms, extending the support we previously mainly had on Mac OS X. This allows applications that were originally written to work on standard resolution displays, to automatically scale to high resolution displays. Qt will automatically scale the UI to match the display, even when moving a running application between displays with different pixel densities. The new functionality can also be easily added into existing Qt applications, supporting both Qt Widgets and Qt Quick based applications. For more details check our the separate blog post.

Qt 5.6 for Device Creation – Windows host, Virtual Keyboard and Yocto Project

As Qt is all-about cross-platform and over the past years we’ve worked a lot in making embedded development as seamless as desktop or mobile development, we’re really excited about a new device creation feature in Qt 5.6: A lot of convenience has been added to creating devices with Qt 5.6 by enabling embedded Linux development through Windows host computer. This allows developers to directly develop and deploy to their embedded Linux hardware from a Windows host computer. To learn more about this and how to get started, please see the separate blog post.

The Qt Virtual Keyboard has also been upgraded to Qt 5.6, with a lot of new features such as handwriting recognition. Please see the relevant blog post and video about Qt Virtual Keyboard.

Finally, another big convenience for the embedded workflow with Qt for Device Creation has been the Boot to Qt software stack, that allows immediate start with Qt on a development board. The stack has been customizable through the Yocto Project tools before. Now, we’ve worked to improve our conformance with the Yocto Project and the Yocto meta layers so that it’s even easier to customize the Boot to Qt stack or pull in all relevant Qt pieces straight to your own Yocto-based builds.

For a full list of Embedded Linux news for Qt 5.6 with eg. board support updates see this blog post.

Qt WebEngine

Our Chromium-based browser engine, Qt WebEngine, has seen some major improvements since Qt 5.5. It is now based on Chromium 45, and with this comes a lot of new features and bug fixes from the Chromium project. In addition, Pepper plugins (PPAPI), such as Flash, are now supported. Qt WebEngine can now also honor the Qt proxy settings and the WebActions API that existed earlier in Qt WebKit has now been ported to Qt WebEngine.

We’ve also added a new Qt WebEngineCore module for new low-level APIs. This includes features such as support for custom URL schemes, intercepting and blocking network requests and for tracking and blocking cookies.

Finally, Qt WebEngine on Linux now uses many of the system libraries instead of bundled ones.

Other features

The Qt Location module that allows easy integration of maps, navigation and points-of-interests (POIs) to your Qt applications is now fully supported. The module is plugin-based, allowing you to select the location service provider backend, and to extend the API with your own backends. With Qt 5.6 we’re providing plugins out-of-the-box for HERE, Mapbox and Open Street Map backends.

Qt 5.6 has improved compatibility with C++11 and the STL by adding features such as reverse iterators for all our container classes, a key_iterator for QHash and QMap, and a const_iterator for QByteArray.

We’ve added a new QVersionNumber class, added support for HTTP redirection in QNetworkAccessManager and added many other smaller features.

OpenGL ES 3 support has been improved helping the development of embedded or mobile apps that want to make use of OpenGL ES 3 features.

Our dock widget infrastructure has seen quite some improvements, making it possible to programmatically resize docks, drop dock widgets into floating docks and re-arrange tabbed docks.

Qt Multimedia got a new PlayList QML type and an audio role API for the media player. Qt Canvas 3D now supports Qt Quick Items as textures and can directly render to the QML scenes foreground or background.

We’ve filled many platform dependent feature gaps. For example, Qt NFC is now supported on Android, Qt Positioning on Mac OS X and Qt WebView on WinRT.

In addition, a huge amount of smaller new features, bug fixes and changes that improve performance and reduce memory consumption have gone into this release.

Removed content

With 5.6, Qt WebKit and Qt Quick 1 will no longer be supported and are dropped from the release. The source code for these modules will still be available. You can continue to compile and use these modules, but we will not be supporting them any longer.

For security reasons, the MNG and JPEG2000 image format plugins are not part of the binary packages anymore. Users needing those can still build them from source but should be aware of the fact that the underlying MNG and JPEG2000 libraries have known security issues.

Qt Creator

In addition, the release updates Qt Creator to the latest version, please have a look at the Qt Creator release blog for more details.

Preview of Upcoming Modules

The installer packages of Qt 5.6 also provide a technology preview releases for three new modules we aim to support with the upcoming Qt releases. Qt 3D, which has been available as a preview earlier, has received many improvements and new functionality. Qt Quick Controls 2 is a complete re-implementation of the previous Qt Quick Controls allowing greatly improved performance especially on embedded devices. Qt SerialBus provides a preview of two widely used industrial buses: CanBUS and ModBus.

New offering for start-ups and changes in open source licensing

Last week, we announced the details of our long-awaited offering for Start-ups. With the Qt 5.6 packages, that option is now rolled-out and available for purchase through the Qt webshop! For more details, read more about the Qt Start-up Plan.

In addition, earlier this year, we announced changes around our future open source licensing options, mainly moving from LGPLv2.1 to LGPLv3 and open-sourcing a lot of formerly closed components under GPL. These changes do not yet affect Qt 5.6 directly but everything we do from now on. Especially if you are developing with Qt under an open source license, you should read the announcement carefully to understand the forthcoming licensing changes. So, please see the related blog post and visit our Licensing FAQ for more details.

Learn more – Upcoming Webinars

Join us to hear all about the 5.6 release in our live overview webinar. Follow the link and register:

Monday, March 21, 2016 at 6 p.m. CET (Europe) | 9 a.m. PT (America)

In addition, we have a whole line-up of webinars scheduled for the following weeks around Qt 5.6 features as well as other interesting topics. See the full events calendar for details and registration links!

Download

As always Qt 5.6.0 can be downloaded through your Qt Account web portal or from qt.io/download.

I hope you will enjoy this release. We are going to support the 5.6 series for a long term, which should make it a great basis for many software projects.

The post Qt 5.6 released appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1Rm0UhE

Qt Creator 3.6.1 released

We are happy to announce the release of Qt Creator 3.6.1.

A few crashes were fixed, as well as some issues with the Clang code model, and a few regressions that sneaked into debugging. Please check our change log for a more detailed list of bugs that were fixed in this release. We also added Qt 5.6 as an option to the QML related wizards, and added Microsoft Visual C++ Build Tools on Windows.

Our binary packages are now based on Qt 5.6.0, which was released today as well and comes packaged with Qt Creator 3.6.1.

You find the opensource version on the Qt download page, and commercially licensed packages on the Qt Account Portal. If you are evaluating Qt you can go straight to http://ift.tt/XbP7NM. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on irc.freenode.net, and on the Qt Creator mailing list.

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

Source :- Qt Blog http://ift.tt/1pL37Nx

Qt 5.7 Alpha Released

I am pleased to inform that we have released Qt 5.7 Alpha today. As always, it is only available as a source package, mainly focused for those interested in studying the features and APIs. For those interested in using Qt 5.7 to develop applications, it is better to wait for the Beta release.

We have been developing Qt 5.7 in parallel with Qt 5.6 LTS, and thus Qt 5.7 is already at the Alpha milestone. For more information about the Qt Roadmap as well as more details what Qt 5.7 brings, please check the recent Qt Roadmap blog post.

In addition to updates for the existing modules, Qt 5.7 introduces several new modules, please see New features of Qt 5.7 wiki page as well as Documentation snapshot for Qt 5.7 for more details.

If you want to give Qt 5.7 Alpha a spin, get the packages from download.qt.io and tell us in the Qt mailing lists how to polish Qt 5.7, or submit bug reports via bugreports.qt.io.

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

Source :- Qt Blog http://ift.tt/1pASBZ0

Qt + Start-Ups = Awesome !

Qt has always been a technology available for everyone. From the very beginning, it was open source. Qt’s innovative licensing model has enabled a vast number of people and companies to use Qt under a license that allows them to satisfy their individual project needs. With our renewed agreement with KDE, we have been enabled to offer even more features to the open source community, while also bringing value to our commercial users. We see a continued and growing interest in our commercial offering and are now in a position to provide an alternate licensing solution for smaller businesses. With the new agreement, we promised to deliver a solution for small businesses, and today, we are proud to announce the details of the new commercial license offering for start-ups!

What is so excellent about this license offering compared to former “Indie” schemes is that you can distribute your applications to all our supported desktop and mobile platforms. In other words, this license covers application development the very same way our standard Qt for Application Development license does. It entitles you to the full usage of Qt for Application Development and the freedom to package and sell your product under terms and conditions of your own choosing under the full commercial Qt license!

Now get this! We want to kick-start this license offering with a great deal: For the first sixty days after release, if you commit to a yearly subscription, the monthly equivalent will be only $49/month! That gives you full access to develop on and deploy to all our supported desktop and mobile platforms, for only $588.

After the introduction offering ends, we will still offer a significant advantage to those who commit to a year, with an equivalent price of $79 per month, summing up to an annual price of $948. In case you want more flexibility, our standard pricing of this license will come in two flavors, and the most flexible option is to pay as you go, for only $99 per month through monthly billing.

So now is the time to decide what you want to pay: $49, $79 or $99 per month? The choice is yours!

So, what is the catch, you might ask? As an offering for start-ups, this license is reserved for companies that are actually still small. To qualify for this license, your annual revenue cannot exceed $100,000.  We really hope this will increase the adoption of Qt for all the innovators out there aiming to bring the next big thing market, and how great would it be if we could all proudly say “Hey, that’s built with Qt!”

So, how to get this? Hold on, but not for long! The product is available for purchase very soon: we will roll this out with the Qt 5.6 release that is right around the corner!

For more details, and soon, for purchase, see the start-up plan web page!

The post Qt + Start-Ups = Awesome ! appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1U1aZH5

Wiki Week coming up in two weeks!

Last May we had the first Qt Wiki Week, where we worked on making the Qt Wiki more readable and improved the place overall. And the frontpage got a major overhaul by Wieland.

The week was fun and now we are doing it again. The second ever Qt Wiki Week will take place two weeks from now, starting Monday 21.3.2016.

The Qt Forum Wiki discussion area is the place to bring in ideas to improve the Qt Wiki and things to do during the week.

You can participate from anywhere, and help make the Qt Wiki a better place for everyone from beginners to hard core Qt developers!

Mark your calendars!

The post Wiki Week coming up in two weeks! appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1R2Ts0R

Throwback to Qt at Embedded World 2016

Once again, Qt participated the Embedded World conference, and how!

Embedded World 2016 was held in Nürnberg, Germany, Feb 23^rd – 25^th and it is considered to be the largest embedded development trade show. The event organizers estimated more than 25,000 visitors, 1,600 speakers and 900 exhibitors, and Qt was highly visible all-around the exhibition. In addition to our own booth, filled with Qt demos, Qt Partner and customer products, as well as live coding sessions, you could spot Qt-powered products and showcases within various industry use cases around the area. It’s overwhelming to witness how widely Qt fits into all kinds of modern embedded use cases.

For a glimpse (#throwback) of the atmosphere and the showcase selection, take a look at this video with yours truly summing up Qt at Embedded World 2016!

 

The main themes for the Qt showcases were around

• Qt in Automotive: See how Qt and the Qt Automotive Suite power the IVI and digital instrument clusters of modern vehicles.
• Qt in Industrial Automation: Real-life use cases of Qt.
• Qt and the Internet of Things: Create full IoT systems of connected devices with one technology
• Facilitating the embedded workflow and shortening the time-to-market with productive Qt tooling

 

A special Thank You to all the partners showcasing joint Qt solutions together with us:

In addition, Thank You to Formlabs for providing the awesome Qt-powered 3D printer Form 2 and to NW Global Vending for the Qt-powered Wittenborg 9100 coffee moments at the booth!

Even though we’ve been opening up our space more and more year by year, we again had a pretty fully packed Qt showroom for the whole three days, massive, I’d say! Thanks for everyone visiting us, hope you had a great and educational time! Hope to see you soon, for instance at the Qt World Summit 2016 in October!

The post Throwback to Qt at Embedded World 2016 appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1R2HtR2

Creating Digital Instrument Clusters with Qt

Qt is widely used in automotive infotainment systems with a number of OS and platform configurations. Some of the car manufacturers have already introduced Qt also in their digital instrument clusters. We believe there will many more in the coming years. Therefore, we have started focused research and development during last year to make cluster creation with Qt more efficient, and recently presented the first generation demonstrator at Embedded World 2016 in Nürnberg, Germany.

In the automotive industry there is a strong trend to create instrument clusters using digital graphics rather than the traditional analog gauges. Unlike in the first digital clusters in the 70’s using 7-segment displays to indicate speed, today’s cars typically show a digital representation of the analog speedometer along with a wide array of other information, such as tachometer, navigation, vehicle information and infotainment content. The benefits compared to analog gauges are obvious, for example it is possible to adapt the displayed items according to the driver’s needs in different situations, as well as easily create regional variants or adapt style of the instrument cluster to the car model.

The cluster demonstrator we created is running Qt for Device Creation version 5.6 on NXP’s widely used i.MX6 CPU. To show the possibilities Qt brings, we are actively leveraging Qt functionality such as Qt Location for mapping data and GPS coordinates, Qt Multimedia for reverse camera view, Qt SerialBus for transfer of vehicle data via CanBUS, and Qt 3D for visualization of the vehicle model in the diagnostics view. The whole UI is built with Qt Quick, and the logic is created with C++ using the versatile Qt APIs.

The following video presents the cluster demonstrator as shown in the Qt stand at the Embedded World event:

Main display of the cluster is a 12,3” HSXGA (1280×480) screen and the second screen used in the demonstrator is a touch panel for simulating events such as turn indicator, putting gear to reverse, tire pressure dropping, a door being open, etc. The controller sends information via the CanBUS to the cluster, which then reacts to the events accordingly.

The demonstrator is running on embedded Linux, using the Qt for Device Creation as baseline. In addition to embedded Linux, Qt supports many real-time operating systems, which are commonly used in the digital instrument clusters. Using a real-time operating system makes it easier to achieve a functional safety certification for the system, as some real-time operating systems are already certified according to the needed functional safety standard requirements.

Our research and development efforts continue with a goal to make it straightforward to build leading digital instrument clusters with Qt. We believe that Qt is a good choice for building both the infotainment system as well as the cluster, and that it is beneficial to use the same technology in both these screens. Stay tuned for more, or contact us to discuss how Qt can be used in automotive and other industries already today.

The post Creating Digital Instrument Clusters with Qt appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/24Dj6xh

Qt Virtual Keyboard Updated with Handwriting Recognition

We are proud to present the new release of Qt Virtual Keyboard with Hand Writing Recognition (HWR), performance improvements, Nuance T9 Write integration, and support for Traditional Chinese language!

Qt Virtual Keyboard is now updated with new features and versioning scheme. As part of the recent licensing change announcement, the formerly commercial-only feature, the Qt Virtual Keyboard is now available also with GPLv3 license for open-source users, in addition to commercial Qt licensees. We released a technology preview of Qt Virtual Keyboard 2.0 a while back, and have now been improving it based on the feedback received. We have also adapted a new version numbering scheme: the Qt Virtual Keyboard now follows Qt versions. With the nupcoming Qt 5.6, Virtual Keyboard is still packaged only to the commercial installers, open source users need to get it from the repository. From Qt 5.7 onwards, Qt Virtual Keyboard is also included in the open source installers.

Qt Virtual Keyboard is a fully comprehensive out-of-the-box input solution. The most important new features of the Qt Virtual Keyboard include:

• A reference implementation of handwrite input method with Lipi toolkit alphabetic + numeric recognizer integration (English)
• Performance optimizations for Lipi toolkit
• Accelerated processing of HWR recognition results
• Full screen HWR mode (on-top writing)
• Nuance T9 Write HWR integration
• Word reselect for Hunspell word prediction
• Support for runtime language switching (from the application)
• Traditional Chinese keyboard layout

Check out the following video to see the latest version of the Qt Virtual Keyboard in action:

Full screen HWR mode (on-top writing)

In the technology preview, the HWR integration used only the regular keyboard layout as HWR input area. In the new fullscreen HWR mode, which can be used in addition, the whole screen is used as an input area instead. Fullscreen HWR mode can be activated from the keyboard by double tapping the full screen HWR button. When the fullscreen HWR mode is active the keyboard is hidden. Trace input is activated and inactivated from a floating button on screen. Fullscreen HWR mode is then deactivated by double tapping the floating button. The switching from writing to selection mode and back is done by single tapping the floating button.

Handwriting in fullscreen mode

Performance optimizations for Lipi toolkit

We are using Lipi toolkit as an open source alternative handwriting recognition engine. Based on the technology preview, we found out that it did not perform well enough on low-end hardware. One obvious reason for this is that the Lipi toolkit was not optimized to run on embedded devices. We conducted some analysis and the performance is now improved by code-level optimization. With that, we have improved the performance by a neat 10-40% in recognition and data model loading!

Accelerated processing of recognition results

The Qt Virtual Keyboard runs the HWR tasks in a separate background thread. This allows the UI thread to continue its operation while the HWR tasks are running. But the recognition results could be produced even faster by starting the recognition already while waiting for the timeout of the user input.

Nuance T9 Write HWR integration

Nuance T9 Write is a commercial HWR engine, which can be enabled at compile time, if the user has a suitable license from Nuance. It is much faster than the Lipi toolkit on embedded hardware. Nuance T9 Write engine is integrated to Qt Virtual Keyboard as an alternative recognition engine for HWR mode. The initial Nuance T9 Write integration supports Latin languages, and is implemented in such a way that it is easy to support also the non-Latin languages in future releases. The integration can also be used with the on-top writing mode. Current support contains x86 and ARM targets.

Word reselect for Hunspell

Added word reselect feature for Hunspell input method. The word reselect allows the user to activate predictions / spell corrections for an existing word by touching the word in the input field. Before it was not possible to reselect a word.

Support for runtime language switching from the application

Earlier versions only supported to switch the language by pressing the language button on the virtual keyboard but there was no way to change the language from the program side. Because Qt API does not provide a uniform mechanism to change the input language, the QInputMethod API provides the current input locale as read-only property. Now the virtual keyboard settings API is extended to include options for controlling input language.

• New properties locale, availableLocales and activeLocales are added to settings
• The locale(if defined) overrides the system default locale in startup
• The locale property can also change the runtime language
• The availableLocales property is read-only and provides the list of “installed” locales
• The activeLocales is application defined subset of availableLocales specifying the locales which can be activated runtime. If the list is empty, then all the available locales are active

Traditional Chinese

Added support for Traditional Chinese / Cangjie input method. The input method implementation is ported from Apache 2.0 licensed 3rd party library.

The Qt Virtual Keyboard supports 3 different Chinese input methods:

• Pinyin(Chinese simplified)
• Cangjie
• Zhuyin

The type of available input methods is configured at compile time.

Get Qt Virtual Keyboard

Qt Virtual Keyboard is included in the commercial Qt 5.6 packages, Qt 5.6.0 final being released later in March. It has now also been contributed to open source under GPLv3 license by The Qt Company, and will be part of the Qt 5.7 release packages. If you are an open source user, please check the code from the repository. If you already have a commercial license, you can choose to install the new Qt Virtual Keyboard with handwriting support in conjunction with Qt 5.6.

The post Qt Virtual Keyboard Updated with Handwriting Recognition appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1LwRkvS

Qt 5.6.0 Release Candidate Available

I am happy to announce that Qt 5.6.0 Release Candidate is finally available!

Please download it and take a tour. With the RC, Qt 5.6 is very close to final release and all feedback is welcome to ensure the best possible 5.6.0 release:

• Report new bugs to bugreports.qt.io
• Send e-mail to Qt Project mailing lists or contact us via IRC

More information about Qt 5.6.0 release can be found from Qt 5.6.0 new features page, Qt 5.6 Beta blog post or from the Qt Documentation snapshot.

If you have existing online installation, you can update Qt 5.6.0 RC by using maintenance tool. You can also download new installers (online or offline) from the Qt Account (for commercial users) or from download.qt.io.

The post Qt 5.6.0 Release Candidate Available appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1LDPlRb

Qt Roadmap for 2016

The year 2016 is very exciting for Qt as we will publish three important Qt releases: Qt 5.6 in March, Qt 5.7 targeting May and Qt 5.8 targeting October. I’ll walk you through the most important content of the releases, and explain the rationale behind our roadmap.

Overall Strategy and Focus Areas

The overall Qt technology strategy is based on the following main principles:

1. High-quality cross-platform application development- reach your end users on all of their screens
2. Powering the future of embedded devices, and with an additional focus on certain key industries
3. Shortening the overall time-to-market with a productive development environment and ready-made solutions

As Qt is a cross-platform toolkit catering dozens of different use cases in various industries, the items we do for the horizontal offering benefit the majority of Qt users. However, we have also taken explicit steps towards targeting our product offering more towards certain key industries. An example of this is the Automotive industry with our Qt Automotive Suite product offering. In addition, we are also looking closely to other industries such as Industrial Automation, Medical, Set-top-Box/DTV and Internet of Things.

Our philosophy of industry-specific development is to adjust Qt functionality according to the specific needs of the industry but generalizing it into the horizontal Qt offering so that will benefit the whole community—for instance instead of just building a Qt CANBus API, we are building a Qt SerialBus API with a CANBus implementation, and extend the API with other implementations such as Modbus or OPC-UA.

The roadmap items planned for 2016 and further are directly based on these three principles: improving our cross-platform functionality with stable and up-to-date desktop and mobile support, extending our offering for embedded industries, or facilitating the overall development workflow with more powerful and integrated tooling.

Qt 5.6 – The First Long-Term Supported Qt 5 Release

Qt 5.0 was released in 2012 and started a new era for Qt. Qt 5 is built from the ground up to leverage hardware acceleration for amazing graphics performance, and intuitive Qt Quick for application creation, while still based on the solid and performant C++ foundation proven with the earlier Qt versions. Since 2012 we have worked hard for bringing support for leading mobile platforms, extending the feature set, enabling efficient device creation, as well as improving tooling and maturity of the framework.

Long-Term Support with Qt 5.6

Qt 5.6 is the first Long-Term Supported (LTS) version of Qt since Qt 4.8. As part of our LTS promise, we guarantee that Qt 5.6 will be supported for three years via standard support, after which additional extended support can be purchased. During this time period, even though following Qt releases (Qt 5.7, Qt 5.8 and so on) are available, Qt 5.6 will receive patch releases providing bug fixes and security updates throughout the three-year period after the release.

With Qt 5.5 (released in June 2015) we had a strong focus on improving quality and providing feature parity between platforms, for example in multimedia and connectivity areas. Qt 5.6 is extending the same principle to provide a solid baseline especially for application development. Qt 5.6 provides support for both C++98 and C++11 compilers, just like before. The next release, Qt 5.7, will drop support for older compilers allowing to leverage C++11 functionality in the Qt modules themselves. So, for those wishing to use compilers such as VS2008, VS2010, and gcc 4.6, Qt 5.6 will be an excellent choice in the years to come.

Cross-platform High-DPI Support

One of the most important new features of Qt 5.6 is the cross-platform support for High-DPI screens, which allows applications written for standard resolution displays to be automatically scaled when shown on high-pixel-density displays. Using the new High-DPI support, Qt automatically adjusts font sizes, window elements, icons and graphics in general in a Qt application based on the pixel density. Applications can adjust automatically when the user moves a window from one display to another with a different pixel density.

We are in the final steps of getting Qt 5.6.0 released in March 2016. To learn more about what is included in Qt 5.6, check the wiki page for New features in Qt 5.6.

Qt 5.7 – A Lot of New Features and Changes in the Open Source Licensing

Leveraging C++11 in Qt Modules

Qt has supported use of C++11 in applications for a long time. With Qt 5.7 we are taking a major step and using C++11 also within the Qt libraries, allowing Qt to move forward together with the modern C++ development. Having Qt 5.6 as an LTS release enables us to provide good support for older, C++98, compilers for many years still while being able to leverage C++11 to make Qt 5.7 and beyond even better. One of the first modules taking advantage of C++11 is the new Qt SerialBus module which is built with C++11 from the ground up. Going forward, we will utilize the new features of the modern C++ language both within the existing Qt libraries and for the creation of new modules.

Overwhelming Amount of New Modules with Qt 5.7

Qt 5.7 will introduce a couple of new modules, which have been available as technology previews in the earlier Qt releases:

• Qt Quick Controls 2 – Fully rewritten, performance optimized set of UI controls for Qt Quick applications
• Qt 3D – Multi-threaded 3D engine for Qt C++ and Qt Quick
• Qt SerialBus – Use various bus communication from a Qt application, initially CANBus and ModBus

There will also be two new technology preview modules included in Qt 5.7:

• Qt Wayland Compositor TP – Multi-process support for embedded devices
• Qt SCXML TP – Improving our state machine framework with new State Chart APIs

In addition, Qt 5.7 includes a lot of modules that have been previously available only with the commercially licensed Qt:

• Qt Charts – Versatile set of chart types for 2D visualization of data
• Qt Data Visualization – Versatile set of chart types for 3D visualization of data
• Qt Purchasing – Cross-platform purchasing API for application stores
• Qt Virtual Keyboard – Customizable virtual keyboard and handwriting recognition front end supporting multiple languages
• Qt Quick 2D Renderer – Running Qt Quick 2 applications without OpenGL hardware acceleration

Changes in Open Source Licensing

There are changes to open source licensing with Qt 5.7. LGPLv3 was introduced as a license option with Qt 5.4 and with Qt 5.7 we are going all in with LGPLv3, no longer offering LGPLv2.1 as a license option. In addition to commercial and LGPLv3 licenses, there are options to use GPLv2 or GPLv3 for most of the Qt functionality. With this change, we are open sourcing a lot of the formerly-closed components under GPLv3 unifying the product offering for application development. As this is an important change, please check the License change FAQ or read the detailed blog post about the upcoming license changes.

We have been working on Qt 5.7 in parallel to Qt 5.6 and the feature set of Qt 5.7 is already frozen. Qt 5.7 Alpha will be released soon, and in the coming months, we will be releasing Qt 5.7 Beta and Release Candidate – according to the usual process. We are targeting to release Qt 5.7 in May 2016. To learn more about what is coming with Qt 5.7, check the wiki page for New features of Qt 5.7.

Qt 5.8 – Configurability, Optimization and Graphics Backend Renewal

We are planning a couple of very important improvements to Qt 5.8, which will be developed further by subsequent releases. The most important research and development items for Qt 5.8 include:

• Increasing configurability
• Optimization of memory requirements
• Building the foundations for next generation graphics
• Built-in Qt Quick Compiler

In addition to these, there will also be many other new features in different areas of Qt, but let’s go through the most important ones now.

Increased Configurability and Reduced Footprint

Qt 5 has a modular architecture allowing to take only the used modules into the application or device. Unfortunately, not all the modules are fully independent, so there often is need to include some unnecessary code in order to use the desired functionality. This is typically not a major issue for a desktop or even mobile application, but for embedded devices it often leads to manual work to optimize the binary size.

The intention is to create a minimal configuration for Qt Quick based devices by modifying Qt Core, Qt GUI, Qt Declarative, as well as possibly some other modules. We want to reduce the amount of dependencies and optimize the functionality in order to reduce the footprint for a low end configuration of Qt. As there are multiple different use cases, each requiring a slightly different set of features, we are also aiming to make it easier to only include the needed functionality into the application / device binary. This allows to expand the install-base of Qt powered devices and to utilize Qt technology in lower-level devices than before.

Enablers for the Next Generation Graphics

A recent trend in graphics has been enabling the use of hardware acceleration on a much lower level than before. The most important new low-level graphics API’s include DirectX 12 from Microsoft, Metal from Apple and the just released Vulkan from the Khronos group (the industry standard consortium behind OpenGL and many other well-known specifications). Qt has been pioneering use of OpenGL, and we naturally want to benefit also from the new possibilities provided by these graphics APIs.

Qt 5 graphics are tightly coupled to OpenGL, which we believe will be very important also in the years to come as OpenGL is widely available on most platforms. On Windows, we are using the the ANGLE library to provide mapping between OpenGL and the Windows’ graphics APIs. With Qt 5.8 we are aiming to remove the hard dependency to OpenGL from Qt SceneGraph and to create new backends for different graphics APIs. We do not expect this work to be complete with Qt 5.8 but to have the basics in place. This allows to leverage the latest graphics APIs and later on, also remove ANGLE from our Windows port.

Built-in Qt Quick Compiler

We introduced the Qt Quick Compiler with Qt 5.3 as a commercial-only feature. For Qt 5.8, we aim to bring a new kind of built-in Qt Quick Compiler for all Qt 5.8 users. The current Qt Quick compiler takes QML files and compiles them to native code showing a big difference in performance on operating systems where one cannot use a just in time compiler, namely iOS and WinRT. It is also very useful for improving load times of Qt Quick applications, as all of the parsing work now happens at compile time. This is especially interesting for startup times of applications and boot times of Qt based embedded devices. As a third benefit, the compiler helps to keep application source code safe, because it is no longer necessary to ship the sources as part of a Qt Quick application.

The new Qt Quick Compiler will be built into Qt Declarative providing two modes. In the Runtime mode it provides a storage (cache) of just in time compiled code on disk making second runs faster. In the Build time mode it works similar to the currently available Qt Quick Compiler, i.e. compiling QML to C++ during the application build time. Therefore, it makes also the first run faster and secures the source code better against reverse engineering.

These are a few examples of the things we are working on for Qt 5.8, but please note that none of the features is yet confirmed. During the next half a year we will be busy implementing these and other features for the Qt 5.8 release in October 2016.

Qt Creator 4.0 – New features, Modern Looks and Improved CMake Support

In addition to Qt versions, we are of course releasing new Qt Creator versions during 2016 – starting with Qt Creator 4.0 in April 2016. Many earlier commercial-only features such as Advanced Profiling, Static Analyzer and Qt Quick Designer features, will also be part of the open source version of Qt Creator 4.0. To celebrate the new major version of Qt Creator, the icon set and theme have received some polish providing modern looks. Behind the scenes, we are tuning the plug-in interface, leveraging Clang more than before and greatly improving the support for CMake.

During the coming months we will host several webinars about the key features in Qt 5.6 and 5.7. There will also be many blog posts about the new innovations in Qt, just like before. If you want to learn more, please contact our sales teams or join the discussion in Qt mailing lists and Qt Forums.

I believe 2016 is a very exciting year for Qt and I hope you agree!

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

Source :- Qt Blog http://ift.tt/1QbsmlZ

Get ready to have your socks knocked off @ Embedded World 2016

Embedded World, the leading international fair for embedded systems, is almost upon us. This year’s event will offer breakthrough new ideas around embedded operating systems, safety and security, connectivity, and energy efficiency concepts supporting the Internet of Things.

Come visit the Qt booth (Hall 4 – 308) and our partners’ booths to see demos of our exciting new features & functions, and to get a glimpse of the future that we are making.

Stand Theatre Presentation – Live Coding

The in-stand theatre will feature daily short presentations and demonstrations:

• 10:00 am – Introduction to Qt for Device Creation
• 11:00 am – Integrating 3D content
• 12:00 pm – Rapid UI Design for Embedded Devices
• 1:00 pm – Showcasing Qt Multimedia
• 2:00 pm – Qt Application Architecture
• 3:00 pm – Using the Qt Virtual Keyboard
• 4:00 pm – Optimizing Qt Applications

 

Demo Kiosks

We invite you to discuss an era of software-defined everything at our in-stand demonstration kiosks where we will feature a range of demos focused on Qt in Automotive, Qt in Automation and Qt in IoT.

Don’t miss our joint solutions showcased together with our partners:

 

Customer projects

Wittenborg 9100 coffee machine: There’s more than beans to good coffee. There’s Qt. Come and enjoy a cup of Qt! Created by Adeneo Embedded. Built with Qt. Running on NXP. Need I say more?

Formlabs Form2 desktop 3D printer: Connected 3D printer powered by Qt. This should be fun!

 Qt Under the Hood – Get a sneak peek at what we’ll be featuring

 Concept application for Car Instrument Cluster HMI

• We use this demonstration application to research different UI concepts in vehicle instrument clusters and to integrate different Qt technologies relevant to the automotive industry.
• Qt Technologies used: Qt Positioning and Location, Qt3D, Qt Multimedia, Qt CAN Bus
• Cluster Hardware: i.MX6 Sabre Lite, Quad Core ARM Cortex-A9, KOE 12,3″ HSXGA (1280×480) display module
• CAN Control unit: i.MX6 Sabre Lite with touch screen

Qt Quick Controls UI

• Demo application showing the new Qt Quick Controls
• Qt 5.6 beta running on i.MX6
• Showing a dynamic touch interface with fluid transitions
• Utilizing a preview version of Qt Quick controls optimized for embedded devices

Qt Tooling

• Qt Quick Compiler: Compile QML source code into native machine code
• Qt Quick Profiler: Advanced performance analysis of your application
• Clang Static Analyzer: Find issues by source code analysis
• Qt Test Runner: Build and run autotests for your projects

Qt State Machine Framework

• The Qt State Machine framework provides classes for creating and executing state graphs.
• This is done by defining possible states that the system can be in and how the system can move from one state to another (transitions between states).

Qt SCXML

• The Qt SCXML module provides functionality to create state machines from SCXML files.
• Dynamically creating state machines (loading the SCXML file and instantiating states and transitions) and generating a C++ file that has a class implementing the state machine.
• Support for data models and executable content.

Qt Wayland Compositor

• The Qt Wayland Compositor API provides a way to write your own custom compositor for embedded or desktop.
• Multi-process UI on embedded hardware
• New, easy and convenient Qt API
• Ability to write a Wayland compositor in pure QML
• Demo is running on i.MX6

 

Schedule your private meeting

Besides checking out the demos, we could exchange ideas or discuss any questions you might have from a technical point of view or regarding the best license set-up for your specific project needs. You can book your meeting with our subject matter experts today by sending an email to anca.cioaca@theqtcompany.com.

 

Redeem free-of-charge exhibition ticket now

Click here to register now. Enter the voucher code B318984 to receive your free-of-charge exhibition ticket in advance (instead of Euro 25.00).

 

We look forward seeing you at Embedded World 2016 in Nuremberg on 23-25 February 2016.

The post Get ready to have your socks knocked off @ Embedded World 2016 appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1KCvYNr

QtCon in Berlin 1st -4th September 2016

Mark your calendars Qt Contributors!

Qt, KDE, VideoLAN, Free Software Foundation Europe and KDAB teaming up to bring you QtCon.

QtCon is not just this year’s major Free and Open Source event in Europe for participants with an interest in Qt, but also a unique forum for talks and knowledge sharing in a state-of-the-art environment. We are bringing together our annual events KDE Akademy, VideoLAN Developer Days, Qt Contributors’ Summit, FSFE Summit and KDAB Qt training day under one roof.

2016 is a special year for many open source projects: KDE has its 20th birthday along with Free Software Foundation Europe and VideoLAN having their 15th birthdays. There will be celebrations!

The dates:

• 1st September — Qt Training Day by KDAB
• 2nd – 4th September — QtCon with multiple tracks of interesting talks for everyone
• 5th – 8th September — KDE continues with Bird of a Feather (BoF) and coding sessions

The call for talks and workshops will be published later in the spring.

 

The post QtCon in Berlin 1st -4th September 2016 appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1Tsa6qB

The Qt Company joins Khronos Group and promotes Vulkan

We are happy to announce that The Qt Company has joined as a contributor member to the Khronos Group. The Khronos Group is a not for profit industry consortium with over 100 member companies working together with open standards for the authoring and acceleration of parallel computing, graphics, dynamic media, computer vision and sensor processing on a wide variety of platforms and devices. Khronos members are able to contribute to the development of Khronos API specifications and have early access to specification drafts and conformance tests. As a member we are able to work even closer with Khronos and its members to make sure Qt is a spearhead implementation of the most relevant Khronos APIs.

From Qt perspective the most prominent Khronos standard has been OpenGL, which provides a powerful, low-level interface between software and acceleration hardware, and it is operating system and window system independent and therefore it has been a good foundation for a cross-platform development framework. For a long time Qt has offered and easy way to integrate OpenGL content to the applications and starting from Qt version 5.0 OpenGL has been the foundation of Qt graphics architecture. Qt has been also actively developing technologies on top of other Khronos standards such as WebGL for a Javascript API for rendering 3D and glTF for streamlining the 3D content loading especially in embedded devices and OpenCL for parallel programming.

Today Khronos has announced a new API called Vulkan which is a low-overhead, cross-platform 3D graphics and compute API for modern GPUs.  As we expect that Vulkan will quickly gain strong foothold and driver support we are actively working on implementing the Qt support for Vulkan together with  the Qt community, our partners and other members of the Khronos Group.

 

 

 

 

The post The Qt Company joins Khronos Group and promotes Vulkan appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1PYPDaE

Share Your Qt Passion – Qt Merchandise Store

Share your Qt passion with all!

Do you love Qt? Would you like to share the passion with all of your friends and team mates?

Go to the Qt Merchandise Store and get Your Qt items today, and be a trend setter of all time. We have an amazing Qt 20th years Anniversary T-shirts for both genders, Qt Hoodies, as well as very cool Qt Mugs and so on. Of course there are an organic options available too, if you wish to save the planet.

You can find a link to the Merchandise Store in Qt.io site too (bottom right), or just follow the link to Qt Merchandise Store.

If you wish to get some other Qt powered stuff, please contact us via info@theqtcompany.com

The post Share Your Qt Passion – Qt Merchandise Store appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1Xnmibj

Qt World Summit 2016 | Be there. Be Qt.

Some say 13 is an unlucky number, but in this case we think the luck is with us. The 13^th  annual Qt event will be located at a fantastic venue on the shorefront of San Francisco this October. Last year’s event concluded with great reviews from the technology business managers and developers who joined us in Berlin from all over the world. (Watch QtWS15 recap here.)

The Qt Company will continue to offer such excellence and inspiration at Qt World Summit 2016 on October 18-20 with leading technology innovators, industry experts, startups, and device creators sharing their insight on the future of cross-platform application development and device creation. We’ll have keynotes and sessions covering everything from technology strategy and product lifecycle management to in-depth technical talks on new APIs, best practices, training and live coding.

Mark your calendars and be sure to stay informed by signing up for the latest event updates about special early bird promotions, speaker announcements and the like.

So wherever you are in the world, we hope you’ll plan to join us in San Francisco for Qt World Summit 2016.

The post Qt World Summit 2016 | Be there. Be Qt. appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1Q5DyvR

Qt 5.5.1 for VxWorks 7 Released

I am pleased to announce that we have now released fully supported Qt 5.5.1 for VxWorks 7 Real Time Operating System (RTOS). Older version of VxWorks has been supported with Qt 4.8, but the port has now been updated to Qt 5.5 and a new major version of VxWorks. With the new version released today it is possible to run the Qt 5 goodies such as OpenGL accelerated Qt Quick 2 on top of VxWorks 7. The release is available for all existing Qt for VxWorks licensses as a new downloadable item in the Qt Account. 

The goal of the new port is to provide a similar level of Qt functionality as the earlier Qt 4.8 port does, as well as to take advantage of the great graphics capabilities of Qt 5. In addition, Qt Creator IDE has integrated support for VxWorks, and deployment of a Qt application to a development hardware running VxWorks is accomplished with a single click. VxWorks development with Qt 5 can be done using both Windows and Linux development hosts.

The following video clip shows Qt 5.5 on top of VxWorks 7 running on a Freescale i.MX6 development board:

The new Qt 5.5 port for VxWorks 7 supports most of the essential Qt modules:

• Qt Core
• Qt GUI
• Qt Network
• Qt Multimedia (audio output only)
• Qt QML
• Qt Quick
• Qt Quick Controls
• Qt Quick Dialogs
• Qt Quick Layouts
• Qt SQL
• Qt Test
• Qt Widgets

In addition to these, the following add-ons are supported:

• Qt Quick Compiler
• Qt Charts
• Qt Data Visualization
• Qt Virtual Keyboard
• Qt Concurrent
• Qt Graphical Effects
• Qt Image Formats
• Qt OpenGL (only for porting form Qt 4, new applications should use OpenGL support in Qt GUI)
• Qt Platform Headers
• Qt SVG
• Qt XML Patterns

The new Qt 5.5 port requires VxWorks 7. We have used Freescale i.MX6 as the reference hardware for the Qt 5.5 for VxWorks port. Multiple other CPUs are supported by VxWorks 7 and most of the x86 and ARM based CPUs with OpenGL support are possible to be enabled for the Qt port with an additional effort.

Holders of a valid Qt for VxWorks license can download the new release from their Qt Account web portal and run it on top of the December 15th GA release of VxWorks 7 RTOS. If you are interested in learning more about Qt 5.5 for VxWorks 7, check the documentation. If you wish to conduct a technical evaluation, please contact us to request an evaluation.

To find the latest port in action, please join us 23rd – 25th February at Embedded World where The Qt Company and Wind River will showcase a secure, connected medical device demonstration featuring Qt 5, VxWorks 7 and Wind River Helix Device Cloud on a Freescale i.MX6. We will be at Hall 4, booth #4-308.

To learn more about Wind River VxWorks 7, please visit the VxWorks website or contact Wind River.

The post Qt 5.5.1 for VxWorks 7 Released appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1SFvedf

Upcoming maintenance break on the Qt Forums Monday 8.2.2016

Hello,

We will have a maintenance break on the Qt Forums early Monday morning 8.2.2016, starting around 7.00 CET.

The target of the break is to do a major version update and do some cleaning of the database at the same time.

The break will last an estimated three hours, so we should be back online at aroung 10.00 CET. We’ll be updating the status on twitter as we get things done.

Sorry for the inconvenience.

The post Upcoming maintenance break on the Qt Forums Monday 8.2.2016 appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1UJywJO

Qt and Direct3D 12 – First Encounter

The landscape of graphics APIs is changing. Qt Quick 2, released with Qt 5.0 in 2012, was betting heavily on OpenGL and OpenGL ES 2.0. There have been changes and improvements since then – the Qt Quick 2D Renderer was introduced, experiments with software rasterizers were made, and enablers for newer OpenGL versions got added all over the Qt graphics stack. However, as Lars mentioned in his Qt World Summit 2015 keynote, the situation is changing: new, low-level, more efficient APIs like Vulkan, Metal and Direct3D 12 are about to become widely available. Some of these are tied to certain platforms, making them the best choice when targeting the platform in question, while others are expected to be present on a wider variety of systems. At the same time betting solely on a complex, accelerated API is not always the best choice: traditional, desktop user interfaces running on older hardware are sometimes better served with plain old CPU-based rendering.

Therefore, unsurprisingly enough, one of the research areas for upcoming Qt versions is making the graphics stack, and in particular, Qt Quick, more flexible, with support for different graphics APIs as well as software rendering.

Such research work often leads to useful side effects: this post is about one of these, a simple Qt module enabling easy integration of Direct3D 12 rendering into a standalone Qt window – or alternatively QWidget-based applications – and making it easier to get started and experiment with modern D3D techniques while continuing to enjoy the familiar APIs, tools, and development environment Qt and its ecosystem offer.

What it is

The QtD3D12Window module, living in a qt-labs repository, is a Qt 5.6 module providing a QD3D12Window class similar to QOpenGLWindow, a handy qmake rule for offline HLSL shader compilation via fxc, and a comprehensive set of examples for a number of basic use cases (inspired by Microsoft’s own Hello World samples).

What it is not

Before going further, let’s reiterate what this module is not: it is not a way to run existing Qt applications on Direct3D (that is exactly what ANGLE provides when it comes to D3D9 and 11), nor does it support Qt Quick in any way. It is also not something that will get added to Qt in its current form, and it is not a complete engine or framework of any kind (the interface QD3D12Window offers is likely insufficient for more complex, multi-threaded approaches).

Window

The first step for integrating custom rendering code using a new graphics API is to make the rendering target a QWindow’s underlying native window. Currently OpenGL is the only choice and it is deeply integrated into Qt both internally (QPA interfaces, platform plugins) and externally (public APIs, see the QOpenGL classes in QtGui for instance). This is expected to change in the future, but for now, for our standalone D3D experiment, we will just do everything on our own. Qt’s windows platform plugin makes it easy to obtain the native window handle (HWND) as that is exactly what QWindow::winId() returns in Qt applications running on Windows. We can then use DXGI to enumerate the available adapters, pick either a hardware one or WARP, and create a swap chain. QD3D12Window handles all this, with defaults that are good enough for the typical basic applications.

Speaking of DXGI, this marks our first foray into graphics adapter and device management: while with OpenGL and its usual windowing system interfaces such capabilities are limited, other APIs (especially the ones tied to platforms with a suitable driver model) may offer a lot more when it comes to discovering graphics adapters and managing device changes, removals and resets during the lifetime of the application. Such functionality, on platforms and APIs where available, is expected to get more focus in Qt in the future.

While implementing QD3D12Window, it turned out there was no need to do much generic plumbing – thanks to the way QOpenGLWindow and QRasterWindow had been introduced back in Qt 5.4: the common base class QPaintDeviceWindow (somewhat misleading in the D3D case as our window here is not suitable for QPainter-based painting) provides all the necessary infrastructure so subclasses can focus on the graphics API specifics while getting the basic, consistent Qt functionality – like update() – out of the box. This is good news since it allows easy experimenting with other APIs as well in the future (QMetalWindow, QVulkanWindow, you name it).

Class

QD3D12Window mirrors QOpenGLWindow which in turn is based on QOpenGLWidget/QGLWidget’s well-known initializeGL – resizeGL – paintGL interface, with GL becoming D3D, naturally. There are two new functions subclasses may reimplement: releaseD3D and afterPresent. The latter is invoked every time after issuing a Present call: most simple applications will wait for the GPU via a fence here. The former is used to make applications able to survive device removals: when the graphics device becomes unavailable, this function is invoked and is expected to release all resources it has created during initialize/resize/paint. QD3D12Window will then then take care of starting over and invoking initializeD3D again. This way the application can remain functional even when a driver update or a timeout in shader execution occurs.

The best is probably to dive straight into the examples, looking at hellotriangle for instance shows that if you haved used QOpenGLWindow or QOpenGLWidget before, QD3D12Window will present no unexpected surprises either.

Widgets

So now we can have a top-level window with nothing but our awesome D3D12-rendered content in it. This is excellent but what about having some traditional user interface controls in there? For now, the approach that is usable with QD3D12Window is to make it a native child window via QWidget::createWindowContainer(). This comes with the usual limitations so be sure to read the documentation first. Nonetheless it will work fine for most simple purposes.

hellooffscreen, one of the QD3D12Window examples

Shaders

The handling of shader code and compilation is another very interesting topic. With OpenGL, Qt and Qt Quick bet on runtime compilation due to that being the only universally available solution not involving vendor and platform specifics. With other graphics APIs in the future, it is expected that Qt will focus more on offline compilation, integrating it into the build system as much as possible. Besides the obvious performance benefits, this drastically improves the development workflow as well: getting a proper compiler error right when hitting Ctrl+B in Qt Creator can easily feel infinitely superior to the “old” way of browsing the debug output while running the application.

The QtD3D12Window module comes with a simple qmake rule that allows invoking fxc.exe during build time. All the examples use this to generate header files where the compiled bytecode is provided as a plain char array. Take a look at the the .pro file for one of them and the shader setup for the pipeline state. Simple and easy, isn’t it?

All this is not completely new to Qt: the bundled ANGLE in qtbase performs shader compilation in the same manner. However, that is hidden to and not usable by application-level D3D code, while the hlsl.prf file here can be copied over to the Qt SDK’s mkspecs/features folder, making it available to any Qt application.

Graphics Debugging

QD3D12Window automatically enables the D3D12 debug layer. This is extremely useful in practice as many of the common mistakes made while getting started with D3D12 result in human readable, verbose and actually helpful debug messages. However, you may want to disable this when doing performance testing or overhead comparison.

Another helpful tool is the graphics debugger included in Visual Studio. One way to launch this for Qt apps is doing devenv /debugexe qtapplication.exe from a developer command prompt and hitting Alt+F5. (alternatively, generating Visual Studio project files with qmake -tp vc may work too) This proved to be quite useful while developing even our simple examples – for instance the ability to inspect graphics resources and see if we managed to correctly generate all mipmap levels is immensely helpful.

Examples

As mentioned before, the module comes with a set of examples that cover the basics and may be useful to anyone getting started with D3D12 development. See the readme for an overview.

That’s it for now, hope you find our little labs module useful. Happy hacking!

The post Qt and Direct3D 12 – First Encounter appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1SkPVcs

Using Qt 3D to visualize music

As the development of the Qt 3D module is proceeding we wanted to give it a try and test how one could visualize music using the module. The result of this experiment was a new example, Audio Visualizer Example, to the Qt 3D module.

Audio Visualizer Example playing Lost Neon Sun by Tiltshifted

The example shows how you can use Qt 3D rendering with Qt Quick elements. The 3D content is rendered using the Scene3D type. The bars are objects in NodeInstantiator and they are animated to visualize the magnitude of the music played. On top of the scene we’ve placed buttons to pause/play and to stop the music. These buttons are Qt Quick elements. The music is played using MediaPlayer provided with Qt Multimedia module.

In the example there’s a curve shaped 3D entity to show the progress based on the duration of the played track. There’s also a prism 3D entity to show the title of the example and the song. The prism shows the title of the song while the song is played and the title of the example becomes visible when the playing is stopped. The titles are placed on different edges of the prism and the angle of the prism is animated once the title needs to be changed.

If you want to give the example a try you can find it from codereview.qt-project.org under examples\qt3d\audio-visualizer-qml. We are aware that there are still some improvements that could be made to the backend performance to make the animation of the bars smoother, but as Qt 3D is Technology Preview in the upcoming Qt 5.6 release these improvements are more than likely.

This example was created to give some ideas of what you can achieve using Qt 3D. We hope you like it!

The post Using Qt 3D to visualize music appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1TnoGPd

Iori Ayane – Qt Champion

We start the introduction of the 2015 Qt Champions with Iori Ayane who is an active participant in the Japanese Qt scene.

Qt is big in Japan, Iori is the second Japanese Qt Champion in two years. There is a really impressive community of Qt users in Japan with regular meetups and activities.

Iori first saw Qt at a workshop in Nagoya in 2011 held by Suzuki-san (Qt Champion 2014).

The thing that really resonated for Iori was Qt Quick, which he immediately started using after the workshop and hasn’t stopped since.

Among the projects he has made are:

• a Twitter client, that he used as an introduction project for himself. It started off as a Windows Mobile project, but worked on multiple platforms including all desktop platforms, Android and Meego (Nokia N9)
• A space invaders style space shooter, that was coded in under a week. (The graphics are fan art for Madoka ☆ Magica, a Japanese anime)
• An Android custom theme viewer application, used for viewing Android custom themes on the PC while you create them. It works with a Japanese custom Android ROM.
• A tool with which you can play web games and easily share screenshots from them to twitter. It’s a web browser with tools specifically to take screenshots and share them.

While Iori has coded a lot, the thing that sets him really apart is that he has written several books on Qt in Japanese. This also started much like his coding with Qt Quick. After coding with Qt Quick for a while Iori felt that Qt Quick is such a wonderful technology that it should be more widely known. However there were no books in Japanese at the time. Iori had written about Qt Quick on his blog, but it felt limited, so he wrote an introduction to Qt Quick in Japanese and got it published with the help of friends.

Iori presenting Lars Knoll with his books at Qt Contributors’ Summit 2015.

On top of all that Iori has also been translating the Qt Installer Framework to Japanese and last year he started committing patches to Qt based on his translation. As a side project from the Qt Installer Framework work, Iori has written a book on the Framework and it has also been published.

The thing that has really impressed Iori in the Qt Community is that everyone is accepted as part of the community. The Japanese Qt community has grown as more people know about Qt and they have regular meetups and workshops in several locations.

Iori himself started with just making small hobby programs and has now made several books and patches to Qt. He likes to tell people about Qt and how easy it is to get started with Qt.

Again, congratulations to Iori on the title of Qt Champion 2015!

The post Iori Ayane – Qt Champion appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1SamOu6

High-DPI Support in Qt 5.6

Qt 5.6 brings improved high-DPI support, in the form of better support for the devicePixelRatio scaling mode. In this blog we’ll look at how to configure and enable it, from the perspective of a Qt application user and a Qt application developer.

Unscaled sammegame vs scaled samegame

Developing applications won’t be covered in depth now, but has to some extent been covered earlier. The short story is that applications generally benefit from this high-DPI mode even without modifications.

This high-DPI mode is a virtualization mode, where there is not necessarily a 1:1 correspondence between a unit in the QWidget/Quick item coordinate system and a pixel on screen. One “unit” then has constant visual size across systems with different display densities, and actual screen pixel density is to a large degree hidden from the application.

Dots Per Inch (DPI) is the traditional measurement for display density, where a standard density display has a DPI value of 72 or 96. Qt as always scaled fonts automatically according to the system DPI, and then the application code was responsible for scaling hardcoded layout sizes. The Qt styles would to a certain degree adapt to the font size. The devicePixelRatio mode is different in two ways: First, the display density is expressed as a scale factor — the devicePixelRatio in Qt — ranging from 1 to n. Second, the scale factor is applied lower in the stack (on the Apple platforms at the OS level), and is less directly used in application code.

There is often a fixed relation between DPI and scale factors on a given platform:

Android DPI and scale factors

class	DPI	Scale Factor
ldpi	120	0.7
mdpi	160	1
hdpi	240	1.5
xhdpi	320	2.0
xxhdpi	480	3.0
xxxhdpi	640	4.0

From stackoverflow. Quiz: Why is 1x 160 DPI on Android, compared to ~90 on desktop?

Demonstrating rendering at display densities on a blog is difficult. What we can do instead change the devicePixelRatio Qt sees while keeping the display scale factor constant. This results in larger visual sizes at higher devicePixelRatios:

The Qt Labs Controls SpinBox at various scale factors, including the unsupported 1.5x.

<strong<Enabling high-DPI support: Qt needs to be provided with a scale factor for all displays on the system. There are several possible sources for the scale factors: The values can be provided directly by the OS, Qt can compute them based on traditional display metrics provided by the operating system (such as the DPI value), or the user or developer can provide them directly. The mechanisms for setting and enabling the sources are environment variables and application attributes.

Historical Sidebar:Qt 5.4 and Qt 5.5 on X11 and Windows supports setting the devicePixelRatio with QT_DEVICE_PIXEL_RATIO=n (integer only). This setter has now been deprecated and replaced with several others, as described below.

Let’s look at three different cases:

Case I: The operating implements high-DPI scaling and provides a scale factor.

This is the situation for the Apple platforms – the OS enables the high-dpi mode, and Qt and the application come along for the ride.

This is also the case for Qt on Wayland when the Wayland display server is configured with scaling enabled:

./weston --scale 2

For the experimentally inclined, Qt for Native Client also gets a scale factor set when browser zoom is activated.

Case II: Qt supports the scaling and computes a scale factor.

Supported platforms: X11, Windows, Android, Eglfs

Qt can enable devicePixelRatio scaling on platforms that do not support it natively. This can be done via an environment variable or an application attribute in the application source code:

QT_AUTO_SCREEN_SCALE_FACTOR=1 ./myApp

QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

Qt will then query the the operating system for display metrics using native API, or in the eglfs case fall back on QT_QPA_EGLFS_WIDTH, QT_QPA_EGLFS_HEIGHT and the display pixel size.

Enabling can also be vetoed, either by environment variable or by the application:

QT_AUTO_SCREEN_SCALE_FACTOR=0 ./myApp

QGuiApplication::setAttribute(Qt::AA_DisableHighDpiScaling)

The use-cases for vetoing are “I’m not getting correct DPI values from my displays” and “my application really needs to work in display pixels”. Note that this vetoing only disables “Case II” scaling: Qt can of course not change how the OS works, and manual set scale factors (below) are also kept as as a separate case.

Case III: Setting a scale factor manually.
Supported Cross-platform.

QT_SCREEN_SCALE_FACTORS=1;2;1 ./myApp

Sets the scale factors for all screens. Screen order is QApplication::screens() order. This setter assumes that text has already been properly scaled for the display, through the DPI setting, and then scales the rest of the user interface to match.

QT_SCALE_FACTOR=2 ./myApp

Sets a global scale factor for the entire application, scaling everything uniformly. This final option is useful for development and testing, and allows you to test any scale factor on any hardware. It can also be useful for some embedded scenarios – for example if you are targeting a single display type with a full-screen application: tweak the scale factor until the UI has the correct visual size.

The finer points:

Q: What happens if I use more than one of these setters?
A: The scale factors are multiplicative. Setting QT_SCALE_FACTOR=2 on a 2x device gives an effective devicePixelRatio of 4.

Q: Are non-integer scale factors supported?
A: Qt uses qreal in the API, and will allow setting non-integer scale factors via QT_SCALE_FACTOR. However, Qt does not guarantee that graphics and styles will be glitch-free in that case. Styles may break first: the fusion style is generally most scalable. The Qt platform plugins round the reported scale factors to the nearest integer.

Q: Could a scale factor of 0.5 allow me to work in device pixels on a 2x device?
A: That’s uncharted waters, but a possibility.

Availability
The new High-DPI functionality is part of Qt 5.6 release. To try it out, please check out the Qt 5.6 Beta.

The post High-DPI Support in Qt 5.6 appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1nMvI49

Notification for all Qt Cloud Services users

Over a year ago we launched Qt Cloud Services, which includes Managed Runtime Services, Managed Application Runtime (MAR), Managed Database (MDB) and Engin.io. Since then we have received great feedback and seen some amazing cloud-connected applications published on the platform. However, the take-up of our services has not been what we had hoped. Consequently, we are currently looking into ramping down Qt Cloud Services. Meantime we will be discontinuing further sales.

We value our customer relationships and therefore believe in providing you as much transparency on this as early as possible. The service will be up and running at least through H1 2016. You will receive at the minimum 3 months’ notice prior to any changes.

Again, we value your business and welcome you to contact us to discuss your particular concerns and questions via info@qtcloudservices.com.

 

Best regards,

The Qt Cloud Services Team

The post Notification for all Qt Cloud Services users appeared first on Qt Blog.

Source :- Qt Blog http://ift.tt/1KBpcBY