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