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

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 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

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

Introducing Long Term Support

With Qt 5.6 we are introducing the first Long Term Supported (LTS) release of the Qt 5 series. There will be several Qt 5.6.x patch level releases created during the next three years – also after the next Qt 5.x releases become available. Commercial licensees eligible for technical support will also be able to submit support requests longer for the LTS release.

Current LTS release has been Qt 4.8, and with its support ending at the end of 2015, it is time to introduce the next LTS release. Qt 5.0.0 was released three years ago and we have done a huge amount of improvements since then, as well as provided many good and widely used releases. Thanks to recent improvements in our releasing infrastructure we now have a sustainable way of developing parallel Qt releases with different sets of supported platforms and compilers.

As 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 (5.7 onwards) are already out, Qt 5.6 will receive patch releases providing bug fixes and security updates. Typically we have provided just one or two patch level releases for each Qt 5.x release, and this is planned to continue also in the future for the non-LTS releases. For Qt 5.6 LTS release the amount of patch releases will be higher, as we aim to provide these throughout the three year period.

With Qt 5.6 we will also roll out a change to the commercial support terms and conditions to recognize LTS versions of Qt, with the three year standard support period. At the same time we are reducing the standard support on non-LTS releases of Qt to be one year. There will be an option to purchase extended support for both LTS and non-LTS releases. The changed support terms do not affect already released Qt 5.x releases, these are supported two years from the release of next Qt version, as defined in the current support terms.

In addition to security fixes, error corrections and improvements provided by the LTS patch releases, we may also add support for new operating system and compiler versions to an LTS release of Qt, when possible. It should be noted that the deprecated modules and technology preview modules are not subject to the LTS.

We had a strong focus on improving quality and providing feature parity with Qt 5.5, for example in multimedia and connectivity areas, and have continued to improve further in Qt 5.6. Our aim is to provide a solid baseline with support for C++98 and C++11 compilers, just like before. The next release, Qt 5.7, will drop support for older compilers allowing us 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 continues to be an excellent choice in the years to come.

The Qt 5.6 Beta release is now available, check it out if you have not yet done so. We are working hard to further fix and polish it with the target of having the Qt 5.6.0 final out in Q1/2016.

The post Introducing Long Term Support appeared first on Qt Blog.

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

Qt 5.6 Beta Released

It is my pleasure to announce that we have released Qt 5.6 Beta today, with binary installers available for convenient installation. Qt 5.6 will be a long-term supported release as we announced at the Qt World Summit in the beginning of October. This means Qt 5.6 support for 3 years along with additional patch-level releases. Let’s take a look at some of the highlights of the forthcoming release!

Long-Term Support

Qt 5.0.0 was released 3 years ago and we have done a huge amount of improvements since then. Therefore, we believe that it is time to create a Long-Term Supported (LTS) release with Qt 5.6. Our previous LTS release was Qt 4.8, which is running out of support in December. Most of you have already upgraded to Qt 5, but if you still have active projects in Qt 4 we encourage to migrate now.

Qt 5.6 will be supported for 3 years, after which additional extended support can be purchased. During this time period, even though following Qt releases (5.7 onwards) are already out, Qt 5.6 will receive parallel patch releases bringing bug fixes and security updates. We will also aim to provide support for new operating system and compiler versions when possible, however this can not be fully guaranteed even for an LTS release. Furthermore, it should be noted that the deprecated modules and technology preview modules are not subject to the LTS.

If you wish to know more about LTS, please check a blog post describing how it works.

New CI system – More Power to Qt Releasing

To build a foundation for the LTS Qt 5 release, we have been developing our continuous integration and releasing infrastructure. After all, as Qt is released and thoroughly tested on a multitude of different platforms and configurations, there is quite an infrastructure behind making all this possible. A new CI system, called Coin for COntinuos INtegration, has been developed and taken into use with Qt 5.6.

With the new CI system we are also using the binaries produced during the CI run in the Qt release packages. This prevents us from having to make new builds for packaging, saving time on integrating changes and creating new packages. In addition to time, the new approach saves a significant amount of CPU cycles in our cluster. Qt 5.6 Beta is the first release with CI produced binaries, so we ask that you please report all issues you encounter. This will help us fine-tune the system for RC and final.

High-DPI Support

One of the biggest new features coming with Qt 5.6 is a fully rewritten cross-platform High-DPI support. It 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. High-DPI support allows applications to adjust automatically even when the user moves a window from one display to another with a different pixel density.

Windows 10 Fully Supported + VS2015 binaries!

We have supported Windows 10 to a large extent already with Qt 5.5 and will now provide full support to both the win32 and WinRT APIs of Windows 10. Qt applications run on Windows 10 desktop PC’s, tablets and phones – and can be distributed via the Windows Store. For native Windows win32 applications moving to Windows 10 and the new WinRT API means a major rewrite, but with Qt is is a matter of simply compiling your application for WinRT.

In addition to Windows 10 support, Qt 5.6 also provided pre-built binaries for the Visual Studio 2015 compiler. Unfortunately, VS Add-In no longer works with VS2015, but we’ll update the VS Add-In for users of earlier Visual Studio versions with the release of Qt 5.6.0.

Other New Features

In addition to things mentioned here, Qt 5.6 adds many other new features and improvements. Please check the wiki for the most important new things in Qt 5.6.

Webkit and Qt Quick 1 Removed

We have removed WebKit and Qt Quick 1 from Qt 5.6 release content. The source code is still available in the repositories, but these are not packaged with Qt 5.6 any more. Qt Script remains deprecated, but is included in Qt 5.6 release.

Qt 5.6 Timeline

With the Beta release now out, we hope to get a lot of feedback from you and will polish Qt 5.6 further towards the Release Candidate and 5.6.0 final in the coming months. We are targeting to release the Qt 5.6.0 LTS final in Q1/2016.

Get Qt 5.6 Beta

Qt 5.6 Beta is now available for download in the Qt Account web portal (register here) or from download.qt.io.

Known issues of Qt 5.6 Beta are listed in the wiki. As always, please provide feedback via the Qt Project mailing lists, IRC, and when appropriate, create bug report at bugreports.qt.io.

 

 

 

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

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

Qt 5.5.1 Released

Today we have released Qt 5.5.1, the first update to Qt 5.5. In addition to improvements and fixes to Qt functionality, it also packs in new Qt Creator 3.5.1.

Qt 5.5.0 released in July introduced many new features and refinements to existing functionality, and the Qt 5.5.1 patch release provides close to 1.000 improvements and fixes on top of it. One of the key drivers for Qt 5.5 has been quality and maturity and we have continued to address items reported by the Qt users with Qt 5.5.1. I am really happy about all the feedback and especially all the contributions we have received.

Qt WebEngine in Qt 5.5.1 includes a couple of security fixes for known vulnerabilities. The list of important changes in Qt 5.5.1 can be found from the change logs. Note that only the most important items are listed in the change logs, for full list of changes it is best to check the git logs.

The Qt 5.5.1 packages also include new Qt Creator 3.5.1. See Qt Creator 3.5.1 change log for the main improvements.

The Qt for Device Creation embedded Linux stack has been updated to use Qt 5.5.1. Support for a new reference device: Kontron SMARC-sAMX6i has also been added. Furthermore, Qt Virtual Keyboard version 1.3.1 is also released today, as well as a technology preview of Qt Virtual Keyboard 2.0.

If you are using the online installer, Qt 5.5.1 and Creator 3.5.1 can be updated using the maintenance tool. Offline packages are available for commercial users in the Qt Account portal and at qt.io/download for open-source and commercial evaluation users.

The post Qt 5.5.1 Released appeared first on Qt Blog.

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

Handwriting Recognition with Qt Virtual Keyboard 2.0

The Qt Virtual Keyboard has been available for a bit over one year and nicely adopted in various devices built with Qt. With the upcoming version 2.0 it will allow gesture based text input as well as typing. In addition to handwriting recognition (HWR) functionality the upcoming Qt Virtual Keyboard 2.0 is bringing performance optimizations, support for Traditional Chinese language, and a couple of other features requested by customers.  

The Qt Virtual Keyboard is a versatile text input component available for commercial Qt licensees. It provides a customizable framework for text input using a virtual keyboard – and now also handwriting recognition. The Qt Virtual Keyboard makes it easy to extent the provided set of input methods and to use different 3rd party engines for word prediction and character recognition. The core features of the Qt Virtual Keyboard are covered in a recent blog post about version 1.3 as well as the documentation.

The most important new features of Qt Virtual Keyboard 2.0 are:

• Generic support for shape recognition based input methods
• Full screen HWR mode (on-top writing)
• A reference implementation of handwriting input method with open-source Lipi toolkit alphabetic + numeric recognizer integration (English)
• Performance optimizations for Lipi toolkit and background processing of recognition results
• Nuance T9 Write HWR integration (commercial product with support for over 40 languages)
• Word reselect functionality using open-source Hunspell prediction framework
• Support for runtime language switching and language selection from a Qt application
• Traditional Chinese support and keyboard layout

We are eager to hear feedback of the new features, especially the handwriting recognition. If you are visiting the Qt World Summit, please drop by and see it in action. There will also be a technology preview release available for download in the coming weeks.

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

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

Wind River VxWorks RTOS support with Qt 5.5

We have been working together with Wind River to bring Qt 5 on top of their most recent release of VxWorks Real-Time Operating System (RTOS), VxWorks 7, and I am happy to share that we are close to being able to make the new Qt for VxWorks port generally available to commercial licensees based on Qt 5.5 in the coming months.

The earlier version of VxWorks, VxWorks 6.9, has been supported by Qt 4.8 since 2012. Today it is possible to run the Qt 5 goodies such as Qt Quick 2 on top of VxWorks 7. The goal of the new port is to provide a similar level of Qt functionality as the earlier Qt 4 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 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 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

Commercial value-add functionality, such as the Qt Quick Compiler, Qt Charts and Qt Data Visualization are also supported with the new port.

At Qt 5.5 for VxWorks 7 general availability, access will be available to all our existing Qt for VxWorks licensees. After it is released, it is available in the Qt Account for holders of a valid Qt for VxWorks development license. The new port requires VxWorks 7, it is not possible to use earlier VxWorks versions with it. We are of course also very interested in hearing more about your Qt 5.5 for VxWorks needs, please contact our sales to discuss more and to receive an early access evaluation version of the new port.

If you are interested in learning more about Qt 5.5 for VxWorks 7, or wish to receive an early access release, please contact us.

For VxWorks 7, please visit VxWorks website or contact Wind River with any of your inquiries.

The post Wind River VxWorks RTOS support with Qt 5.5 appeared first on Qt Blog.

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

Improvements to Commercial Qt Downloads in China

We have changed to a new Content Delivery Network (CDN) for the download of commercial packages and evaluations in China. The new provider will offer better download speed and reliability, especially when using the online installer.

Earlier we have had some issues with the download of commercial packages inside the People’s Republic of China. Especially problematic has been that some online installer downloads have been failing. With the new provider we have improved download speed and reliability. Open-source downloads of Qt are unaffected by this change.

The new system is already in production for the online installer. Later in August we plan to also use it for offline packages downloaded via the Qt Account. Downloads outside China are unaffected and continue to use the same CDN as earlier. However, when the download request is detected as coming from China, we now transfer the connection to the new Chinese CDN system.

If you experience any issues downloading, please contact us via the Qt Support Center inside the Qt Account portal.

The post Improvements to Commercial Qt Downloads in China appeared first on Qt Blog.

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

Qt 5.4.2 Released

Today we have released Qt 5.4.2, the second patch update to Qt 5.4. In addition to improvements and fixes to Qt functionality it also packs new Qt Creator 3.4.1.

Qt 5.4.2 provides important security fixes for Qt WebEngine WeakDH vulnerability (CVE-2015-4000), DoS vulnerability in the BMP image handler (CVE-2015-0295) as well as security fixes for vulnerabilities in image handling of BMP (CVE-2015-1858), ICO (CVE-2015-1859) and GIF (CVE-2015-1860). Qt 5.4.2 also contains updates to the libpng (to version 1.6.17), the libtiff (to version 4.0.3) and the PCRE library (to version r1530) 3rd party components. These provide fixes to known vulnerabilities and provide general  improvements.

Qt 5.4.2 maintains backward compatibility, both source and binary, with Qt 5.4.1 – but not to Qt 5.4.0, which unfortunately broke binary compatibility on Windows when using MSVC 2012 or MSVC 2013. This binary compatibility break was fixed in Qt 5.4.1, thus Qt 5.4.2 maintains full compatibility with the Qt 5 series (except for Qt 5.4.0).

The full list of important changes can be found from the change files for each module.

The standalone packages of Qt 5.4.2 also include new Qt Creator 3.4.1. See the blog post about Qt Creator 3.4.1 for the main improvements.

Today we have also released a new version 1.3 of the Qt Virtual Keyboard adding support to Japanese and Korean languages, for more info about it please check the Qt Virtual Keyboard 1.3 release blog post.

If you are using online installer, Qt 5.4.2 can be updated using the maintenance tool. Offline packages are found from the Qt Account (for commercial users) and from the qt.io download page (for open-source users).

The post Qt 5.4.2 Released appeared first on Qt Blog.

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

Qt Virtual Keyboard 1.3 Released – Adding Japanese and Korean Language Support

Today, we have released a new version 1.3 of the Qt Virtual Keyboard. As new features, we are adding support for Japanese and Korean along with support for Windows desktop.

A big use case over the years for Qt has been in creating embedded devices with an interactive use interface. More and more embedded and industrial devices are moving towards touch screens as their primary interface. As external input devices are no longer used, the device creator often needs to leverage virtual keyboard for text input. Although a virtual keyboard may seem like a trivial UI component, it is actually quite complex. When you think about modern keyboards, input mechanisms, customization, scalability and especially requirements around internationalization & localization, a virtual keyboard can easily become a very complex challenge that could hinder the whole usability of your device if not made properly.

Focus of Qt is to shorten the time-to-market on all aspects of development workflow, so over the past years, we have developed the Qt Virtual Keyboard to provide a full ready-made solution for Qt powered devices. Besides just touch-based screens it also expands to other input mechanisms, like 2/5-navigation (joystick/scrollwheel). The Qt Virtual Keyboard is available with a commercial Enterprise license at no additional cost. Using the Qt Virtual Keyboard in your Qt based devices is easy and we are continuously making sure it works nicely with the new releases of Qt.

Key features of the Qt Virtual Keyboard include:

• Customizable keyboard layouts and styles with dynamic switching
• Predictive text input with word selection list support
• Character preview and alternative character view
• Automatic capitalization and space insertion
• Scalability to different resolutions
• Support for different character sets (Latin, Simplified Chinese, Hindi, Japanese, Arabic, Korean, …)
• Support for most common input languages (see list below), with possibility to easily extend the language support
• Left-to-right and right-to-left input
• Hardware key support for 2-way and 5-way navigation
• Sound feedback
• Cross-platform functionality

The Qt Virtual Keyboard version 1.3 supports the following languages:

• Arabic
• Chinese (Simplified)
• Danish
• English
• Finnish
• French
• German
• Hindi
• Italian
• Japanese (Hiragana, Katakana, and Kanji)
• Korean
• Norwegian
• Persian/Farsi
• Polish
• Portugese
• Russian
• Spanish
• Swedish

If the language you need is not supported, you can add an additional language (see documentation for Adding New Keyboard Layouts).

To see more about Qt Virtual Keyboard, check out the documentation or watch the video about the core features of the Qt Virtual Keyboard:

The new Virtual Keyboard 1.3 is available for device creation customers who have a commercial Enterprise license via the online installer as well as from the Qt Account. If you are not a customer yet, you can evaluate Qt for Device Creation with our free 30 day trial.

The post Qt Virtual Keyboard 1.3 Released – Adding Japanese and Korean Language Support appeared first on Qt Blog.

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

Qt 4.8.7 Released

I am happy to announce release of Qt 4.8.7 today bringing over 150 improvements and bug fixes. Qt 4.8.7 provides important security updates, better support for Mac OS X 10.10 and many requested error corrections. As a patch release, it does not add new functionality and maintains full compatibility with previous Qt 4.8.x releases.

Highlights of Qt 4.8.7 are:

• Security fix for DoS vulnerability in the BMP image handler (CVE-2015-0295) as well as security fixes for vulnerabilities in image handling of BMP (CVE-2015-1858), ICO (CVE-2015-1859) and GIF (CVE-2015-1860)
• Update 3rd party libpng to version 1.6.17 to address known vulnerabilities in previous version
• Update 3rd party libtiff to version 4.0.3 to address known vulnerabilities in previous version
• Better support for running Qt 4.8 applications on Mac OS X 10.10 Yosemite
• Many customer requested bug fixes

A detailed list of the fixes and improvements in Qt 4.8.7 compared to Qt 4.8.6 can be found here.

Many users have already moved their active projects to Qt 5 and we encourage also others to do so. With a high degree of source compatibility, we have ensured that switching to Qt 5 is smooth and straightforward. It should be noted that Qt 4.8.7 provides only the basic functionality to run Qt based applications on Mac OS X 10.10, full support is in Qt 5.

Qt 4.8.7 is planned to be the last patch release of the Qt 4 series. Standard support is available until December 2015, after which extended support will be available. We recommend all active projects to migrate to Qt 5, as new operating systems and compilers with Qt 4.8 will not be supported. If you have challenges migrating to Qt 5, please contact us or some of our service partners for assistance.

The source packages and stand-alone installers for Qt 4.8.7 are available for download from Qt Account for commercial users and qt.io download server for open-source users. For Enterprise and Professional customers, the online installer can also be used for installing Qt 4.8.7.

The post Qt 4.8.7 Released appeared first on Qt Blog.

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

Qt Online Installer Update Released with Optional Qt Account Sign-In

The Qt online installer with optional sign-in to Qt Account is now released. Users of earlier Qt online installers will get this as an update and new users can download the online installer from qt.io or via the Qt Account web portal. Also as promised last month in Lars’ blog about the One Qt Site Unification project, we are now seeking your input (via a survey) on what additional services and features, if anything, you would find a valuable addition to your Qt developer experience (DX) and Qt Account functionality.

As announced last week, the new Qt online installer provides an option to sign into Qt Account. If you enter your Qt Account credentials, the installer will check if there is a valid commercial license associated with your Qt Account. You will then be taken through to commercial installation. If there is no commercial license associated with your Qt Account, installation will provide the open-source version of Qt. If you do not have a Qt Account yet, you can simply create one directly via the installer. Just enter your email (this is address to which your account activation email will be immediately sent upon account creation) and the password you wish to use for Qt Account access and proceed to install. If you do not have a Qt Account and do not want to create one, you can simply skip this by clicking ‘Next’ to proceed with the open source installation of Qt.

 

The Qt repositories and delivery networks for commercial and open source content are separate, so that users with a commercial license of Qt will have access to their commercial delivery system and the additional content their license grants them access to. Users without a commercial license will be able to install the open source version of Qt from the open source delivery system. If you are already using a Qt online installer, you will be provided the new unified installer when using the maintenance tool. You will need to update the installer (maintenance tool), before you download other items. If you do not yet have an online installer for Qt, you can get it from the qt.io Download page or via your Qt Account portal.

The new online installer is built with the brand new 2.0 version of the installer framework. We have worked hard to iron out all possible glitches of the installer, but in case you have problems with it, please file a bug to bugreports.qt.io. Offline installers are unchanged and still use the older version of installer framework.

Take 5 minutes to give us feedback on what functionality you want from Qt Account services.

We are looking at providing you additional services, as well as offering integrated dashboard-like functionality that will eventually put all your Qt services in one unified place, such as Qt Creator and/or a web portal. Qt Account credentials are currently used for signing in to the Qt Wiki and Forum. Commercial license holders can also manage Qt support tickets and downloads when signed in. We are currently working on extending the use of Qt Account for sign in to other systems, such as bugreports.qt.io. To see a list of current benefits of having Qt Account credentials, please visit our Qt Account Benefits page. We will use your input to further develop our service features road map and knowing what you find useful is integral part of planning what we should focus our resources on. We, of course, hope to implement the most popular features and functionality, but can’t make any promises as to what and when. We’ll have more info to share with you at Qt World Summit 2015.

Don’t miss the chance to give your input: Survey open thru Tuesday 19 May 2015.

The post Qt Online Installer Update Released with Optional Qt Account Sign-In appeared first on Qt Blog.

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

Changing Qt Account to be Optional in the Online Installer

Thanks for your feedback to the new online installer asking for a Qt Account signup. We have evaluated the feedback received via the blog, various discussion forums, irc and other channels. Based on all these comments and discussions with our partners we realize that this was not our finest moment. Preventing the growth and usage of Qt in the open source community is not what we want to happen. We did already see a nice jump in the number of Qt Accounts, but it was never our intention to make our valued community and contributors upset with us or stop using and contributing to Qt. We clearly ill-calculated how asking for a Qt Account with the online installer would make our users feel. A mistake. Sincere apologies.

Based on your feedback, we will remove the enforced Qt Account requirement for open source downloads. Instead, we will make it optional. Users can proceed to download by opting out of creating a Qt Account. Just like before, the commercial users need to provide their Qt Account so that we can point them to the additional content and commercial versions of Qt. We very much hope that we will see also many open-source users creating Qt Accounts either when installing Qt, or via qt.io.

The installer team is already looking at making this change, and we hope that an update can be rolled out next week. Even though the change may look small there is quite many things that we always need to verify before we roll out an update to production. So, please bear with us while we are implementing the change.

We will continue to develop our plans of bringing integrated services to Qt via the Qt Account. Next we are aiming to provide a single sign-on solution through the Qt Account to all our services (forums, wiki, bug reporting, customer portal, etc). Some of the services already leverage Qt Account for sign-on and new services will follow in the coming months. We are committed to developing Qt Account further and want to make it valuable for all users of Qt.

We do hope that this eases your concerns, and that we can continue with your trust. The open source community is what Qt is built on and we value your efforts and feedback greatly. We are very happy to have an active ecosystem around Qt and appreciate the dialogue. So, thanks again for your feedback, discussions and for guiding us in this tough endeavor. We are glad that we have a lot of passion for Qt and for its ongoing greatness in the community.

The post Changing Qt Account to be Optional in the Online Installer appeared first on Qt Blog.

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

New Unified Qt Online Installer Available

Today we released a new unified online installer for commercial and open-source versions. Previously, we have had  separate installers for each version. Now Qt Account is used for validating the Qt license and determining if a commercial  or open-source version should be installed.

Unification of Qt systems has been ongoing for a while and we have now reached a major milestone with the unified online installer. We no longer have two separate online installers to create, test and release. Also, it is now easier to migrate from open-source to commercial license of Qt.

The Qt repositories and delivery networks for commercial and open-source content are still separate, so that users with a commercial license of Qt will have access to their commercial delivery system and the additional content their license grants them access to. Users without a commercial license will be able to install the open-source version of Qt from the open-source delivery system.

If you already have a Qt Account, enter your credentials when asked:

If you do not yet have a Qt Account, you can create it conveniently from the online installer:

When you enter your Qt Account credentials, the installer will check if there is a valid commercial license associated with your Qt Account, and you will be taken through to commercial installation. If there is no commercial license associated with your Qt Account, installation will provide the open-source version of Qt. If you do not have a Qt Account yet, you can simply create one directly via the installer. Just enter your email (this is address to which your account activation email will be immediately sent upon account creation) and the password you wish to use for Qt Account access and proceed to install. Be sure to activate your Qt Account as instructed in the email. You may also create a new Qt Account at qt.io, if you prefer.

In addition to being the place to manage support tickets and downloads for commercial license holders of Qt, Qt Account credentials are used for signing in to the Qt Wiki and Forum. We are also working hard to extend the use of Qt Account for sign in to other systems, such as bugreports.qt.io. To see a list of benefits of the Qt Account, please visit our Qt Account Benefits page.

The unified online installer is built with the brand new 2.0 version of the installer framework. We have worked hard to iron out all possible glitches of the installer, but in case you have problems with it, please file a bug to bugreports.qt.io. Offline installers are unchanged and still use the older version of installer framework.

If you are already using a Qt online installer, you will be provided the new unified installer when using the maintenance tool. You will need to update the installer (maintenance tool), before you download other items. If you do not yet have an online installer for Qt, you can get it from the qt.io Download page or from the Qt Account portal.

The post New Unified Qt Online Installer Available appeared first on Qt Blog.

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

Windows 10 Support in Qt

Exciting times are ahead for the Microsoft Windows platform, so we want provide you with an update on our plans. Windows 10 is approaching and there is a large amount of improvements coming with Qt 5.5, making the WinRT / Windows Store Applications support better. With this improvements, we would also like to announce that starting with Qt 5.5 we will offer the Qt port of WinRT/Windows Store Applications under the LGPLv3/GPLv2+/Commercial licenses.

Windows 10 Provides Compatibility with Existing Qt Applications

Microsoft has indicated that they are planning to release Windows 10 this summer, so many Qt users have been curious about the support level we are aiming to provide with Qt 5.5 and subsequent releases.

The good news is that all Qt applications created with earlier Windows versions will run on Windows 10 without any limitation. That includes classic desktop (Win32) applications as well as Windows Store Applications (WinRT). One thing to mention is that on Windows 10 also the Windows Store Applications will be windowed and not only in full-screen anymore. This is supported already if you have an application in the Windows Store and Qt 5.5 will provide further improvements to smoothen glitches on resizing.

Qt Offers Portability from Win32 to WinRT

The new API for Windows Store Applications (WinRT) is very different from the Win32 API used by the classic Windows applications. Therefore, a developer who has created a native Windows application needs to in essence re-create the application to use the new API for Windows Store Applications. Fortunately, the situation is much better with Qt-based Windows applications.

For any application which uses just the functionality provided by Qt, the only required step is to recompile your Qt for Windows application with WinRT port of Qt to make it a Qt for Windows Store Application. If your application uses native Win32, some further work is needed, but the Qt parts are really easy. Unfortunately, the automatic styling functionality is not available for the WinRT port of Qt, so although both widgets and Qt Quick work well, the application does not automatically get the platform style.

Improvements to the Qt for WinRT (Windows Store Applications)

Microsoft’s new API for Windows Store Applications is available in PCs, tablets, phones, and later on, also on embedded devices. A great value is that the same application can run across a wide variety of devices, and all the different kinds of devices can access the common store for applications. Qt applications have been available for earlier versions of both Windows Phone and WinRT for a while now, and we can leverage the same baseline for Qt 5.5 and Windows 10 support.

For Qt 5.5 we have put a lot of effort into further stabilizing and improving the quality of our existing Qt for WinRT port, which supports all variances of Windows Store Apps (desktop and phone). We have been going through the feedback from previous releases and addressed all the most requested items. Qt 5.5 greatly improves, for example, Multimedia support and Visual Studio integration/deployment.

Support for Visual Studio 2015

So far Qt for WinRT applications have been built with Visual Studio 2013, which continues to work with Windows 10. There is also a new compiler coming later this year in Visual Studio 2015, which is a major update on the development environment. Visual Studio 2015 Community Technology Preview (CTP) has been out for a while, so we have been doing some research on how Qt behaves against that and some commits are already in the 5.5 branch, while others are still a work-in-progress. Visual Studio 2015 is still under heavy development, so there are currently some workarounds needed to build Qt with it. After the final version is out, we intend to provide support for it in a Qt 5.5.x patch-level release, including pre-built binaries.

Furthermore, the first preview of the Windows 10 SDK has been released, which is valid for Windows Store Apps, including Windows 10 Mobile. We are able to compile Qt against that SDK as well, with a couple of changes required. Similarly as for Visual Studio 2015, we are planning to fully support Windows 10 SDK, after it is officially released.

Use of LGPLv3/GPLv2+/Commercial License

With Qt 5.5 we are changing the license of the Qt for WinRT port to be LGPLv3 / GPLv2+ / commercial license. We believe that LGPLv3 is a better and clearer license than the older LGPLv2.1, so we want to use it for WinRT / Windows Store Applications in Windows 10 (as well as Windows 8.1 and Windows Phone 8.1). The open-source licenses LGPLv3 and GPLv2+, as well as the commercial licenses of Qt, are compatible with Microsoft’s terms and conditions for the Windows Store.

To learn more why we want to use LGPLv3 in Qt and what it means, please check the blog post about introducing LGPLv3 license option and qt.io licensing pages.

Full Support for Windows 10 Coming with Qt 5.5.x

As Qt 5.5.0 is scheduled to be released before Windows 10, we aim to provide full support for Windows 10 with a Qt 5.5.x patch release after Windows 10 is available. Our intention is to provide initial support for Windows 10 already with the Qt 5.5.0 release, so that users can try out Qt on Windows 10 preview versions. As also the Qt applications created with earlier Windows versions will run nicely in Windows 10, we see that things are in good shape for the upcoming major new Windows release.

The post Windows 10 Support in Qt appeared first on Qt Blog.

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

Qt Weekly #26: Protecting your application against hacking

Open-source applications are open by nature, indented and encouraged for tweaking, hacking and further development. For a business critical application or a device there sometimes is desire to make it closed and prevent modifications. Because of the dual licensing, Qt offers a commercial license option that is well suited for making closed applications and devices allowing many ways of protection. Everything can be hacked, but it is possible to make hacking your Qt based application or device difficult.

For the purposes of this blog post, I have divided the ways to protect your application into three categories: legal means, securing the application and external protection. I concentrate into a few easily achievable and simple ways to make reverse engineering of a Qt based application difficult, not into making a binary fully secure or protected against tampering or copying. If the system needs to be fully secure, it has to be achieved by different means that making reverse engineering harder.

Legal means

Whereas the applications and devices using the open-source licensed Qt should be open for hacking and playing around, it is possible to prevent such when using a commercial license of Qt. One of the most important legal protection means provided by the commercial license of Qt is to forbid modifications and reverse engineering – and using various methods to prevent these. It is quite typical that the end user license agreement of an application or device states that reverse engineering is forbidden, which is allowed for commercial license. However for an application or a device created with the open-source licensed Qt it is not allowed to prevent reverse engineering or modifications, neither in the end user license agreement nor by making it difficult. In addition to legal protection the commercial license of Qt makes it possible to use various technical means to secure your application or device.

Securing the application

As it is allowed to legally prevent modifications and reverse engineering when a commercial license of Qt is used, it is also possible to take actions to prevent these. Static linking is one of the easiest ways of protection as it prevents changing the Qt binary used by the application and also makes reverse engineering harder. With static linking the application and Qt libraries are combined into the same binary. A possible hacker needs to take much more demanding and time consuming ways to modify the behaviour of the system compared to dynamically linked application.

When using static linking a good further measure to protect against reverse engineering is to strip symbol names away from the binary. Depending upon the compiler you use this is either automatically done for release builds, or can be done as an extra step for the statically linked binary. For example, MSVC automatically removes symbol names from a statically linked Windows release binary. On Linux and Mac this can be done with strip command. After the symbol table is removed from the statically linked binary, it is quite well protected against reverse engineering. These steps are easily done and do not require modifying your Qt application source code, thus static linking and removing the symbols can be regarded as the most efficient way to obfuscate the binary and to make reverse engineering difficult.

If use of dynamic linking is needed, some protection against simply changing the dynamically linked Qt library to a new version can be gained via using libinfix to change the library names (e.g. change libQt5Core to stgElse). Another approach is to change the used namespace with configure option –qtnamespace. Namespacing Qt puts all classes inside a defined namespace resulting, for example, QString being called someNewName::QString. In addition to using libinfix and namespaces it is also possible to use a generic c++ obfuscator for Qt applications. The protection gained by using all these means to a dynamically linked library is typically weaker than using static linking. When considering the level of obfuscation, it should be noted that no matter how much the code is obfuscated, it is still eventually possible to reverse engineer.

For Qt Quick applications it is recommended to use Qt Quick Compiler if there is desire to protect the QML parts of the application. While the application logic, and thus typically the most critical parts to protect, is usually done with c++ and therefore always compiled to binary, it is a good further measure to also protect the QML parts of the application. The Qt Quick Compiler compiles QML to binary and protects against reading the QML parts of the application. An additional benefit of the Qt Quick Compiler is improved performance of the application, especially at startup.

External protection

As the Qt application is just like any other binary running in your target operating system and hardware, you can use all generic means available for protection in your environment. Operating system may offer means to digitally sign the applications, as is typically the case with the applications distributed via application stores. There are also many different products available to provide security for application binary, and these typically work for Qt applications as well.

For embedded devices some protection is gained even without any special security hardware, as it is often difficult to get access to and modify software embedded into a physical device. The most efficient protection is to have hardware containing functionality to prevent a modified binary from running (either in the device hardware, or an external one, such as a USB dongle). In some cases it is also possible to leverage another system via a network connection to provide tamper protection. Static linking and obfuscating the binary make reverse engineering difficult, but only the external protection mechanisms of the target hardware and operating system provide full protection.

It should be noted that leveraging external protection typically requires a commercial Qt license, similarly as the other means of preventing user from changing or modifying Qt libraries. LGPLv2.1 is a bit ambiguous when it comes to whether or not the user should be allowed to run the modified application, but it is rather clear that it was the intention. For LGPLv3 it is clearly stated in the license that in addition to being allowed to modify the open-source library the user must be able to run the modified library as part of the system, and that the needed tools to achieve this must to be provided.

Summary

If there is a need to create a closed application or a device, the commercial license of Qt is the right choice. With the commercial license it is possible to utilize various means for making it difficult to modify functionality of the application or device built with Qt:

• Making reverse engineering forbidden in end user license agreement and taking actions to prevent it is allowed when Qt is used with a commercial license.


• An easy way to protect against modifications and reverse engineering is to use static linking instead of dynamic linking and build Qt into same binary with your application to prevent changing the Qt libraries.


• When using static linking it is important to use release builds and when needed to manually strip out the symbols before distributing the binary.


• If dynamic linking is needed, some protection against reverse engineering can be gained by building Qt with different names for libraries using libinfix and changing the used namespace. This mainly protects against user being easily able to change the dynamically linked Qt libraries – the protection against reverse engineering provided by static linking is much better.


• Using Qt Quick Compiler that compiles QML to binary and protects against reading the Qt Quick parts of the application is an efficient way of further protecting your application.


• No need to provide possibility to modify software embedded into a device, thus making it possible to use capabilities of the hardware and the operating system to prevent modifications to system software.

In case you want to learn more about the ways to protect your application, feel free to contact us. We can help you to implement protection for your application both via technical and licensing means.

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