KDE still makes Qt

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

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

KDE still makes Qt

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

Qt World Summit 2017 Wrap-up

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

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

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

 

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

core QtWS team

 

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

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

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

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

Keynotes!

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

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

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

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

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

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

Igor

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

Herb

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

Sessions and the show-floor

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

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

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

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

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

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

 

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

Qt Contributors’ Days and Training Day by KDAB

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

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

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

Final words

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

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

Tero // Project manager for Qt World Summit 2017

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

Static binaries (for Go with Docker)

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

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

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

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

docker run -it alpine:3.6 /bin/sh

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

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

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

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

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

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

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

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

Qt Creator 4.5 Beta released

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

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

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

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

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

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

Get Qt Creator 4.5 Beta

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.5 Beta is also available under Preview > Qt Creator 4.5.0-beta1 in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

The post Qt Creator 4.5 Beta released appeared first on Qt Blog.

Cutelyst 1.9.0 released!

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

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

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

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

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

What is Qt 3D Studio?

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

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

 

What has been done in the past 7 months?

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

Here are a few items we been working with:

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

Integrating Qt 3D Studio UI’s to Qt applications

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

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

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

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

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

Roadmap

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

Qt 3D Studio Roadmap

Early Access Releases

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

1.0  and 1.x releases

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

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

2.0  release

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

Getting Qt 3D Studio

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

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

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

Watch the live streams here

Qt World Summit venue

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

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

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

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

LIVE STREAM TIMES, SPEAKERS AND TOPICS

Wednesday, October 11, 2017

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

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

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

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

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

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

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

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

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

 

Thursday, October 12, 2017

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

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

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

 

With that we hope you will enjoy the live streams!

 

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

Qt World Summit & Open-Source Conference App

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

What to Expect at the Qt World Summit 2017?

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

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

V-Play at the Qt World Summit 2017

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

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

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

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

Schedule Business Meetings with the Qt World Summit App

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

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

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

App Store Google_Play_Badge-1

Get the Open Source Conference App

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

github_logo

Get the Conference App Source Code on GitHub

cross-platform conference app ios android qt world summit 2017

Contact Us or other Attendees with the Business Meet Feature

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

business-meet-and-chat

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

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

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

Meet Us in Berlin!

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

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

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

 

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

Rapid iOS deployment from Mac, Windows & Linux

 

 

More Posts Like This

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

How to Make a Qt app

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

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

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

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

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

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

Read the recent press release...

also on Myscript's website...

continue reading

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

Qt 5.10 Beta Released

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

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

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

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

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

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

SDDM v0.16.0

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

Clazy Results Visualizer for Qt

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

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

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

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

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

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

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

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

[training_callout] continue reading

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

Migrate Your Legacy Code to Qt

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

Benefits of migrating to Qt

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

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

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

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

Want to migrate to Qt quickly?

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

The set of proven steps to make sure you migrate smoothly

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

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

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

Qt 5.9.2 Released

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

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

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

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

The post Qt 5.9.2 Released appeared first on Qt Blog.

Qt Creator 4.4.1 released

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

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

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

We fixed debugging and QML profiling on QNX targets.

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

Get Qt Creator 4.4.1

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.4.1 is also available through an update in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

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

Qt World Summit Conference App – Tech Stack

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

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

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

App Store Google_Play_Badge-1

Schedule Business Meetings

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

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

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

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

Become Friends :)

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

How to use this Social System in Your Apps

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

profile-custom-views

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

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

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

import VPlay 2.0
import VPlayApps 1.0
import QtQuick 2.0

Item { // ProfileView section

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

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

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

}

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

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

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

QR Attendee Badge Scanning

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

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

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

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

qr-code-scanning-qt

Rate Talks

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

Feedback Dialog & App Store Rating Dialog

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

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

Cloud Storage & Cross-Platform Data Syncing

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

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

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

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

More Mobile App Best Practices

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

Single Source Code – Native iOS & Android App

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

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

cross-platform conference app ios android qt world summit 2017

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

Rapid iOS deployment from Mac, Windows & Linux

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

:)

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

Hotspot v1.1.0 adds timeline and recording features

Close to three months after the initial hotspot release, I'm happy to announce the release of version 1.1.0. Quick recap: Hotspot is a graphical frontend to the Linux perf profiler suite. It allows you to visually analyze perf.data files with the built-in Flame Graph and the Bottom-Up, Top-Down, or Caller-Callee data tables. It is a free open source R&D project by KDAB, you can find the code on GitHub.

Version 1.1.0 adds two important new features to this list:

  1. An event time line which allows you to filter the results by time, thread or process
  2. A new record page to configure and run perf graphically from within hotspot. It supports both, launching a new application as well as attaching to running processes.

Additionally, we now also publish an AppImage with this release, which allows you use hotspot quickly, even on older Linux distributions - no need to compile anything anymore! You can find the release downloads on our GitHub page.

continue reading

The post Hotspot v1.1.0 adds timeline and recording features appeared first on KDAB.

Qt World Summit App 2017 – Open Source & Live Now!

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

The Qt World Summit 2017 is around the corner: it will take place in Berlin from October 10 – 12. The Qt World Summit is the biggest Qt conference of the year and a great way to connect with other Qt developers to share experiences and learnings. And to get the latest news about state-of-the-art Qt development, best practices and the upcoming Qt roadmap.

A great conference like this deserves an awesome conference app. That’s why we built one, powered by Qt!

You can now download the app for iOS & Android here:

App Store Google_Play_Badge-1

The app was built with Qt / QML and the V-Play Engine, which allows a native UI and user experience across both platforms optimized for phones and tablets, with just a single source code:

cross-platform conference app ios android qt world summit 2017

Qt World Summit App Highlights

The conference app allows you to:

  • Browse the QtWS 2017 conference schedule.
  • See detailed information for all talks and speakers.
  • Manage your personal agenda by adding talks to your favorites.
  • Connect with other conference participants, chat & schedule meetings.
  • Get notified of upcoming favorited sessions with push notifications.
  • Full-text search of all speakers & talks.
  • Auto-cache the conference data & images locally – the app also works offline.
  • Gamification elements (a leaderboard) award you for starting the app and for favoring and rating of talks.
  • Customize the UI and switch between different native styles and colors.
  • Synchronize your agenda across multiple devices & platforms: simply connect your Facebook account in the app and your agenda is automatically synced between smartphones & tablets on both iOS & Android.

Get the Open Source Conference App

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

github_logo

Get the Conference App Source Code on GitHub

There’s More…

There are several more features coming to the app and will be released next week. Here is a teaser what you’ll be able to do:

  • Scan the conference badge of people you meet at the conference to get all the contact details like email and company name. You can then export all the contacts you met as a csv file ready to import into your CRM, or store the contacts to your phone’s address book.
  • If you want, you can provide more details about yourself, for example what your main Qt interests (like mobile app development) are. By sharing this info, you can connect with other developers with the same interest and schedule a meeting at the conference before it even started.
  • Rate sessions. The winners & results will be announced after the conference by the Qt Company.

 

We’ll publish another blog post where you can see these features in more detail. Meanwhile, have fun creating your personal agenda for the conference with the app and don’t forget to rate it in the app stores. :)
If you did not register for the conference yet, you can register here.

Side note: we will show how we developed this app in a session at the Qt World Summit and how you can develop an app like this too! If you attend the conference, make sure to watch our presentation in the main room C01.

The post Qt World Summit App 2017 – Open Source & Live Now! appeared first on Qt Blog.

GammaRay 2.8.1 Release

We have released version 2.8.1 of our Qt application introspection tool GammaRay. This release contains a number of important bugfixes as well as support for Qt 5.9.2. Especially if you are experiencing corrupt views or crashes when searching in the object tree, or having trouble attaching to a process on Windows, you want to upgrade to the new version. The same applies to users of bleeding edge Qt versions experiencing build failures.

Next to maintaining the 2.8 series we are also hard at work adding new features for the upcoming 2.9 release expected towards the end of the year, such as QML binding inspection, a Qt Quick texture and texture atlas view and Qt Widget tab focus chain visualization.

Since GammaRay 2.8 you also have the possibility to help us focus on the features and platforms most relevant to you by contributing usage statistics (see Help > Contribute... in the GammaRay client). I'd especially encourage users of older Qt versions and compilers to enable this, so we know it's still worth it to support those configurations.

Find out more about the release here... continue reading

The post GammaRay 2.8.1 Release appeared first on KDAB.

Lots of lights: Generating cities

Sometimes data visualization might call for more than a graph - you need to visualize complex data, such as that generated by city lighting, in three dimensions to get the full effect.

KDAB decided to put together a showcase for the Qt World Summit that allowed us to demonstrate Qt 3D's capabilities as a performant next-generation graphics engine, which can draw thousands of lights and objects simultaneously. This also enabled us to show what modern technologies like Qt 3D can achieve when paired with OpenGL, C++ and custom tooling.

What would show a huge amount of dynamic lighting in action better than a city at night?  We couldn't answer that, so, to avoid the tedium of building a virtual 3D world to get us going, we imported data from the freely accessible OpenStreetMap service. OpenStreetMap is a great community and a source of free and open mapping information. Additionally, it allows for the export of street and building data to XML format which can be further post-processed.

Buildings

Our data was filtered according to OpenStreetMap keys, and building locations were extracted as polygonal shapes. From these shapes - according to specific rules - Houdini was used to generate a geometric three-dimensional object out of a single polygon per house. Along with that, texture coordinates were created automatically, too. Texture coordinates tell the graphics card how to map an image - commonly referred to as a "texture" - onto a geometric object much like a present is wrapped in paper.

The OpenStreetMap data contains a wealth of information, such as road surface type, speed limits and the number of floors per building. Our algorithm we used calculates the building's height according to this data and produces an approximation. We used additional properties to provide rooftop variations and create random materials. To keep the performance high, we decided that all buildings should share the same, automatically generated texture atlas. This means that all images we used are combined into a single one so the graphics card has to load and hold just one image in memory for the whole scene.

Traffic

What would a city be without a little traffic? As a challenge, cars should roam the streets of our virtual city, we decided, and of course provide moving light sources. For that to work, we exported OpenStreetMap path data to a custom format and uploaded it to the GPU using a texture. Cars were then animated, instanced and drawn purely on the system's graphics card.

 

Putting it together

Finally, we combined traffic, buildings and a massive amount of lights into a single scene using Qt 3D. In the final demo, a simple QML interface provides the ability to switch different features on and off as well as switch between a real-world city and a completely computer-generated one. Very little effort was necessary to connect the C++ logic to the interfaces, as QML makes those kind of data bindings very easy.

 

Make sure to see for yourself and visit our booth at the 2017 Qt World Summit! continue reading

The post Lots of lights: Generating cities appeared first on KDAB.

Release 2.13.1: Qt Creator 4.4 Upgrade, Mac & Linux Improvements

V-Play 2.13.1 adds support for Qt Creator 4.4 and brings improvements for developers using Mac & Linux. There are also various other fixes and new improvements, for example for the Flurry and OneSignal Push Notifcation plugin.

Let’s get to the details of these improvements…

Qt Creator 4.4 Support

QtCreator 4.4 adds many improvements, especially for developers using C++ in their project. If you didn’t know yet: you can mix C++ and QML code in your V-Play projects. There will be an in-depth blog post how to do this soon!

Our favorite new feature is the new inline annotations in the code editor: errors and warnings are now also shown in the text line without hovering over them. This makes the warnings & errors easier to spot and helps to improve code quality!

Qt Creator 4.4 Inline Annotations

To enable the new annotations, run these steps:

  1. In Qt Creator, click on Help > About Plugins
  2. Enter “Clang” to the filter and enable the ClangCodeModel plugin to load
  3. Restart Qt Creator
  4. Enjoy the new awesome inline annotations :)

There is also a new syntax highlighting for C++ code available now. Local, global and member variables, functions, declarations and output arguments are now distinguishable by their highlighting in the editor. This makes the C++ code better readable and easier to understand.

For iOS & Android developers, these are the highlights:

  • New UI for managing simulator devices on iOS.
  • Added support for Android API levels 25 & 26.
  • Added option to run commands before the Android app starts and after it stopped.

For more details on the new Qt Creator release, see the Qt Blog announcement about it here.

Mac & Linux Improvements

With this update, developers on Mac & Linux have a new “V-Play Kit” available. The benefit of this new solution is, that updating to future V-Play versions that use a different Qt version internally gets a lot easier, because the Qt version is now automatically updated for you.

Important Notice for macOS and Linux Developers

Follow these steps on macOS and Linux because otherwise you will not be able to use the new features of this update and your existing projects will not compile without this change. This is a one-time step required to make updating V-Play versions easier in the future:

1.) After you updated V-Play, open Qt Creator and click on the “Projects” icon on the left. You will now see the new “V-Play Desktop” kit greyed out. Then double-click on the greyed out V-Play kit on the left.

V-Play 2.13.1 Mac & Linux Qt Creator Activate New Kit

After double-clicking on the (new) grey kit, it will be used by default for your project:

V-Play 2.13.1 Mac & Linux Qt Creator Activate New Kit 2

2.) To also set the new V-Play kit as the default for your future projects, click on Tools / Options and select Build & Run. Then select the V-Play Kit and click on the “Make Default” button. Now the new V-Play kit will be the default for all your future projects and it will look like this:

V-Play 2.13.1 Mac & Linux Qt Creator Default Kit Selection

Note: If you already have Qt installed on your PC, installing V-Play on top of your existing Qt installation also gets a lot easier with this new feature! You can add V-Play to your Qt project with this guide.

Flurry & OneSignal Push Notification Improvements

This update fixes an issue for the Flurry Analytics plugin, which caused a crash if you did not set an apiKey.

If you want to send push notifications with the OneSignal plugin to a specific user from the OneSignal dashboard or from your custom server, the userId property now works properly (it returned an empty string before).

Also, the nickname users can enter in the V-Play Game Network ProfileView, will now be stored as a push notification tag for this user. This allows you to send messages to users based on this additional information.

We also updated the OneSignal iOS SDK. If you are using OneSignal for sending push notifications in your app, please download the latest library from here.

You can see these new additions in the OneSignal Dashboard. In this screenshot, you can see the “Player ID” which is now available with the userId property. And the new tag “_vpgnnickname” stored for users who entered a manual nickname:

OneSignal Dashboard User Tag and Player ID

More Fixes & Improvements

Besides the highlights mentioned above, there are many other fixes and improvements for the SDK. Some of them are:

  • Optimize the AppListView cacheBuffer for better scrolling performance.
  • Add a new VPlayGameNetwork::defaultUserName property. Set this property to your preferred default name that users who have not set any custom userName get prepended their userId with. The default value for this property is “Player %1”. For example for an app and not a game, you could set this to “User %1”. Or if you only want to display the userId without any prefix, you can set it to “%1”.
    This enables a better user experience for V-Play apps using V-Play Game Network & V-Play Multiplayer for user login, user management, user authentication and chat messages.

For a full list of improvements and fixes to V-Play in this update, please check out our change log!

How to Update V-Play

Test out these new features by following these steps:

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

V-Play Update in Maintenance Tool

If you haven’t installed V-Play yet, you can do so now with the latest installer from here. Now you can explore all of the new features included in this release!

For Mac & Linux developers, follow the steps explained above.

 

 

More Posts Like This

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

How to Make a Qt app

The post Release 2.13.1: Qt Creator 4.4 Upgrade, Mac & Linux Improvements appeared first on V-Play Engine.

Qt 5.6.3 Released

I am pleased to inform that Qt 5.6.3 has been released today. As always with a patch release Qt 5.6.3 does not bring any new features, just error corrections. For details of the bug fixes in Qt 5.6.3, please check the change logs for each module and known issues of Qt 5.6.3 wiki page.

Qt 5.6 LTS is currently in the ‘Strict’ phase, and only receives fixes to security issues, crashes, regressions and similar. Since end of 2016 we have already reduced the number of fixes going into the 5.6 branch and after Qt 5.6 LTS enters the ‘Very Strict’ phase it will receive security fixes only. The reason for gradually reducing the amount of changes going into an LTS version of Qt is to avoid problems in stability. While each fix as such is beneficial, they are also possible risks for behavior changes and regressions, which we want to avoid in LTS releases.

As part of our LTS commitment, we continue to support the commercial Qt 5.6 LTS users throughout the three-year standard support period, after which it is possible to purchase extended support. For description of our support services, please check the recent blog post describing the Standard, Extended and Premium Support. In May 2017 we released Qt 5.9 LTS, which includes a wide range of new features, functionality and overall performance improvements. We expect to release Qt 5.9.2 patch release still during September, including all the bug fixes of Qt 5.6.3 and many more. To learn more about the improvements that come with Qt 5.9 LTS you can find all relevant blogs and on-demand webinars here.   

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

The post Qt 5.6.3 Released appeared first on Qt Blog.

Qt Installer Framework 3.0.1 Released

We are happy to announce the release of Qt IFW 3.0.1.

3.0.1 is fully compatible with 2.0.5, which means you can update existing online installers with installers built with 3.0.1. Version 3.0.1 includes a lot of bug fixes and also new features.
Here is a list some new features, some to mention:

  • Allow to use the stylesheet to customize UI
  • New –silentUpdate command line option
  • Introduced gui.setTextItems() method
  • Add ApplicationsDirX86 and ApplicationsDirX64 predefined Variables.
  • Add new ‘–sign’ switch to binarycreator for signing OS X app bundles
  • Allow defining non-checkable items – introduces new element ‘Checkable’ for package.
  • Added support for setting descriptions of Windows shortcuts.
  • Add Castilian Spanish translation.

The full list of added features and bug fixed can be found from ChangeLog.

You can download Qt Installer Framework using Qt SDK or using QtAccount or Qt Downloads.

Thank you for everyone involved!

The post Qt Installer Framework 3.0.1 Released appeared first on Qt Blog.

Testing Applications for Color Blindness

At the Randa Meeting 2017 Volker and I decided to write a little KWin plugin. Activating this plugin you can simulate various types of color vision deficiencies, either on individual windows or full-screen. The plugin works by running a fragment shader on the respective window/screen.

Here is a short video demonstrating what we did:

The purpose is to allow everyone to test applications problematic color schemes.
https://en.wikipedia.org/wiki/Color_blindness

The post Testing Applications for Color Blindness appeared first on Qt Blog.

Accessibility improvements in Randa

Accessibility in KDE and Qt is constantly improving. Sometimes a change of scenery helps focusing and brings up productivity. Mix that with a bunch of great people and good things will start happening. It has been possible to create accessible Qt applications on Linux for a while, but of course not everything will just work out of the box untested. A while back Mario asked me to join this year’s Randa Meeting where KDE people discuss and fix issues. It turns out that was a great idea. I haven’t been able to focus much on applications and user experience lately, but with this backdrop it works 😉View of the mountains and Randa village

Upon arrival I sat down with Marco and David of Plasma fame and we quickly got Orca (the screen reader on Linux) working on their laptops. We discussed what is wrong and where improvements would be most needed for blind users to use the Plasma desktop, we got to work and had the first fixes even before lunch, wow. Adding a few accessibility hints and poking hard at keyboard navigation got us much further.

This means that KRunner – Plasma Desktop’s app launcher – is now much more accessible, a great enabler. There’s more work going into the menu and panel, hopefully we’ll see much improved keyboard usability for these by the end of the week. It’s good to see how Qt accessibility works nicely with Qt Quick.

In the afternoon, we had a round of introductions and talks. For accessibility some key points were:
– Don’t do custom stuff if you can avoid it. This includes colors and fonts, but also focus handling.
– Try running your application with keyboard only. And then mouse only.
– Make sure that focus handling actually works, then test with a screen reader.
– Oh, and focus handling. Check the order of your tab focus chain (in Qt Designer or by running your Qt Quick application. While I’ve lately become a big fan of the Qt Quick Designer, I don’t think it allows to detect all corner cases when it comes to tab key handling yet.)
– I should write and talk more about FocusScope, one our our best and most confusing one bit friends in Qt Quick.

Introductions in Randa

I sat down to poke at the systemsettings module, making it easier to debug and a bit more reliable. This morning I sat down with Ade to poke at why Calamares (the installer framework with the highest squid content ever) is not accessible. When running it as a regular user, the results were actually all in all quite OK. But it usually (for historical reasons) gets launched as root. While that may be fixed eventually, it was worth investigating what the issue really is, because, well, it should work. After a bit of poking, comparing DBus messages and then a break (Yoga and Acrobatics), we spotted that an old bug hadn’t actually been really fixed, just almost. Applications run as root would connect to the right DBus bus (AT-SPI2 runs its own bus), but we just failed to actually initialize things properly. Turns out that in this slightly different code path, we’d emit a signal in a constructor, before it was connected to the receiver… oops. The fix is making its way into Qt as we speak, so everything is looking and sounding good 🙂

[Note: the blog post was written yesterday, but I never got around to publishing it, so everything is off by a day, just shift it back by one day. Then you can imagine how I will sit down the next evening for a bit of late night blogging and pancakes (that’s about now).]

The post Accessibility improvements in Randa appeared first on Qt Blog.

Qt 5.10 Alpha Released

I can proudly tell that Qt 5.10 Alpha is released today.

Please check Qt 5.10 New Features -wiki to see what new is coming with Qt 5.10 release. And as usual the official Alpha is a source code delivery only.

Next milestone in our way to final Qt 5.10 release (which is planned to happen at the end of November) will be first Beta release. We are targeting to get it out soon after the Alpha. We will release several Beta releases in similar manner as we did with Qt 5.9 – made available via the online installer. Each new Beta release will add maturity and improvements based on user feedback.

Please download the Qt 5.10 Alpha source packages from your Qt Account or from download.qt.io.

Most importantly, remember to give us feedback by writing to the mailing lists and reporting bugs.

 

 

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

Qt World Summit is Coming

Qt World Summit 2017 is now exactly a month away. Time to get prepared for the event.

If you haven’t yet gotten your tickets, now it is time to visit the registration site.

This year we will have seven incredible tracks of talks ranging from automation to deep dive tech talks.

KDAB is hosting the Qt Training day. The topics range from introductory courses on Qt and QML to more complex topics like modern OpenGL and C++14 and C++17. ICS is joining the Qt Training Day with a training on user experience design for embedded devices.

Don’t forget Contributors’ Days at the beginning of the event. While it is aimed at people contributing code, documentation or their time to the Qt project, it is a fun event for anyone who is deep in Qt coding. The chance to follow core developers present their views on the inner working of Qt and the discussions arising from the talks are definitely worth hearing.

To attend the Contributors’ Days for free, you can use this link to unlock the free Contributors’ Days pass.

No matter which part you’ll be attending, I’m looking forward to seeing you all in Berlin!

The post Qt World Summit is Coming appeared first on Qt Blog.

Qbs 1.9 released

Qbs (pronounced “Cubes”) is The Qt Company’s latest build tool, which aims to be the replacement for qmake in the Qt build system. In addition to its use within Qt, for our customers Qbs will also provide faster build times coupled with a rich feature set in order to reduce build engineering complexity and decrease time to market.

Today I’m excited to introduce you to the latest release of Qbs – 1.9. This is an important release with foundational new features.

What’s New?

In addition to the usual bug fixes and performance enhancements, this release includes two of the most foundational changes to the future of Qbs.

Language Improvements

The first of these is something we call Dependency Parameterization. Depends items can now be parameterized to set special module parameters for one particular product dependency. The new item type, Parameter, is used to declare such parameters in a module, while the new item type Parameters (note the ‘s’) is used to allow products to set default values for such parameters in their Export item.

So, what can dependency parameterization do for you? First, let’s step back and examine the meaning and usage of a Depends item.

Depends items are used to create a dependency between product A and product B, such that the target artifacts of the dependency can be used as inputs to the rules in the context of the depending product. In practice, Depends items have so far been used mostly to link an executable or library to another library. But a dependency is a very abstract concept, and can represent any type of relationship between two products. The fundamental problem is that whatever the meaning of the dependency, how that dependency took effect was only controllable from one side of the dependency relationship – the dependency’s side.

Qbs 1.9 allows this relationship to be controlled from the depending product’s side as well. For example, one of the products in your project may be a plugin which is implemented as a shared library. Your main application should depend on that plugin, because you want to ensure the plugin is built whenever the main application is, but you don’t want to directly link to that plugin because you want to load it entirely at runtime.

In Qbs 1.8, we would create a Depends items pointing to our shared library, like so:

Depends { name: "library" }

But there’s a problem – now our main application will actually link against the plugin shared library, which we don’t want. This is why we need to control the dependency relationship from the depending product’s side as well. In Qbs 1.9, we can now add a dependency parameter to the Depends item, like so:

Depends { name: "library"; cpp.link: false }

This tells Qbs that we want to depend on the “library” product, but don’t want to actually link to it. This gets exactly the result we want – ensuring that “library” is built whenever our main application is, but without creating a direct linking relationship between the two.

So how does it work? First, the cpp module in Qbs declares the availability of a boolean dependency parameter called “link”, using the Parameter item. Whenever a Depends item sets this property, its value will be applied to any input artifacts coming from the target artifacts of that product, when the current product’s rules are processed. The linker Rule in the cpp module then checks the cpp.link parameter of any dependent shared libraries and only links to them if it is true.

You might ask, why go through the trouble of extending the language in this way if we could just express within “library” itself that it should not be linked? Perhaps via using a different file tag for the output? The reason is that you might have multiple products A and B within your project that want to depend on another product C, but A and B both want to depend on C in a different way. For example, if C is a macOS dynamic framework, B might want to Depend on C by linking to it, because B is another library which depends on some of C’s functionality, whereas A is an application bundle that wants to depend on C by embedding it within itself, but not by linking to it, since the A application doesn’t directly call any functions in C.

The dependency parameter that we’ve added so far are cpp.link, cpp.linkWholeArchive, and cpp.symbolLinkMode. Check out the cpp module documentation to find out how you can use them in your projects.

Essentially, Depends items now provide a much more flexible way for build engineers to express the relationship between products, leading to more correct and efficient builds, without complicated hacks and workarounds.

Multiplexing

The other important new feature we have is called Product Multiplexing. This feature replaces and is functionally a superset of the old profile multiplexing functionality we had previously implemented in order to support multi-architecture Android APKs.

The new implementation has been generalized to cover more use cases, and is a lot more powerful. Its primary function is to allow the creation of multi-architecture Android APKs and the creation of multi-architecture “fat” binaries and multi-variant frameworks (where a single framework can contain both a release and debug build of a library) on Apple platforms. We can also easily extend the multiplexing to more areas solely using QML, without having to modify the core build engine.

The problem with the old profile multiplexing is that it enforced a rigid project structure that was inherently dependent on the naming convention of the build profiles that were used. Such a structure wasn’t in keeping with our philosophy to make profiles optional, nor did it play particularly nice with how Qt Creator handles Qbs-based projects.

Enter product multiplexing: instead of multiplexing a product over multiple profiles, we now allow a product to be multiplexed over a number of more general properties. Currently, these are qbs.architectures (which maps to qbs.architecture), qbs.buildVariants (which maps to qbs.buildVariant) and qbs.profiles (which maps to qbs.profile, hence keeping a certain degree of backwards compatibility with the old multiplexing as well).

Product multiplexing works by examining a special property on the Product item called multiplexByQbsProperties, which can be set to the list of properties your product should multiplex over. For example, let’s say multiplexByQbsProperties contains two strings “architectures” and “buildVariants”. Qbs will then evaluate the values of qbs.architectures and qbs.buildVariants, which in turn may contain the values, [“x86”, “x86_64”] and [“debug”, “release”]. Qbs will then build the product N times according to the number of values in the matrix. In our example, 4 configurations of the product will be built: (x86, debug), (x86, release), (x86_64, debug), and (x86_64, release). If the Product’s aggregate property is true, the product will also be built a fifth time, where the values of the multiplexed properties are left undefined. The aggregate product will have an automatic dependency on the original four instances of the product, allowing it to collect and operate on their outputs artifacts.

The aggregate product is used in situations where the target artifacts of the individually multiplexed instances must be combined into one final aggregate artifact that makes up the overall product. For example, bundle products on macOS, iOS, tvOS, and watchOS use the aggregate product to create the bundle artifacts like Info.plist, PkgInfo, etc., which aren’t dependent on a particular architecture or build variant, and also use the lipo tool to join together the built native code for different architectures (like x86 and x86_64) into the final, multi-architecture “fat binary” that goes inside the app bundle or framework.

Due to its general design and easily extensible implementation in the build engine, we hope that in the future we can discover even more use cases for product multiplexing. One case I’ve considered so far but have not yet investigated is building multi-architecture app bundles for the Universal Windows Platform.

Deployment and Packaging

One of the interesting new features with this release is the ability to build macOS disk images with custom backgrounds and icon layouts.

Most applications on macOS are installed via a .dmg file, which is usually customized by a fancy image background and custom icon layout. The problem is, it’s quite challenging to construct such DMG files correctly. The custom background and icon layout relies on several undocumented proprietary file formats, some of which date back to the Mac OS Classic days, and which are even nested within one another.

Most of the existing tools to create DMG files do so by using AppleScript to manipulate the Finder graphically to generate the right icon layout, which is both unstable and incompatible with headless build servers since the necessary OS services to launch graphical applications may not be running at all. Other solutions will try to create the primary .DS_Store file manually, and commit to their source repository. This binary blob is difficult to inspect and edit, and might not be backwards compatible with older versions of the OS, depending on how it was generated.

The solution used by Qbs suffers none of these problems. It generates the necessary files programmatically, in an entirely reproducible manner, and there are no external dependencies that need to be separately installed and zero binary blobs committed to your source repository. It Just Works. Transform this:

AppleApplicationDiskImage {
    targetName: "cocoa-application-" + version
    version: "1.0"

    files: [
        "CocoaApplication/dmg.iconset",
        "CocoaApplication/en_US.lproj/LICENSE",
        // comment out the following line to use a solid-color background
        // (see dmg.backgroundColor below)
        "CocoaApplication/background*"
    ]

    dmg.backgroundColor: "#41cd52"
    dmg.badgeVolumeIcon: true
    dmg.iconPositions: [
        {"x": 200, "y": 200, "path": "Cocoa Application.app"},
        {"x": 400, "y": 200, "path": "Applications"}
    ]
    dmg.windowX: 420
    dmg.windowY: 250
    dmg.windowWidth: 600
    dmg.windowHeight: 422 // this *includes* the macOS title bar height of 22
    dmg.iconSize: 64
}

…into this:

macOS disk image built with Qbs

macOS disk image built with Qbs

Qbs even supports multi-language license agreement prompts that appear when the DMG is opened,  with full Unicode and rich-text formatting support. And no, you don’t have to deal with Carbon resource files from Mac OS Classic to do it!

In order to implement this functionality, we made use of several high quality Open Source Python modules (dmgbuild, ds_store, and mac_alias). I’d like to thank the developer, Alastair Houghton, for his hard work on and maintenance of these modules. The Qt Company has also contributed back a number of fixes and enhancements to these modules as part of the development of this feature.

Other New Features

  • Setting module property values from the command line can now be done per product
  • When rebuilding a project, the environment, project file, and property values are now taken from the existing build graph, which makes builds more self-contained and reliable
  • Rules now have a property requiresInputs. If it is false, the rule will be run even if no artifacts are present that match its input tags
  • Precompiled headers are now used by default if present in the product (cpp.use*PrecompiledHeader defaults to true now)
  • Added support for Unified Headers in the Android NDK
  • The property cpp.cxxLanguageVersion now gets mapped to MSVC’s /std option, if applicable
  • Added a new How-To section in the documentation with step-by-step guides on how to achieve common workflows
  • Context-sensitive help is now enabled for Qbs items in Qt Creator 4.4, which includes Qbs 1.9

Also, the loadFile() and loadExtension() function have now been formally deprecated and replaced by require(), as originally stated in the Qbs 1.8 release blog.

Try It!

The Open Source version is available on the download page, and you can find commercially licensed packages on the Qt Account Portal. Please post issues in our bug tracker. You can also find us on IRC in #qbs on chat.freenode.net, and on the mailing list. The documentation and wiki are also great places to get started.

Qbs is also available on a number of packaging systems (Chocolatey, MacPorts, Homebrew) and updated on each release by the Qbs development team. It can also be installed through the native package management system on a number of Linux distributions including but not limited to Debian, Ubuntu, and Arch Linux. An official Fedora package is in progress and should be available in a future release of Fedora.

Qbs 1.9 is also included in Qt Creator 4.4, which was also released today.

The post Qbs 1.9 released appeared first on Qt Blog.

Qt Creator 4.4.0 released

We are happy to announce the release of Qt Creator 4.4.0!

Qt Creator inline annotations

Editing

If you are using the Clang code model or bookmarks, there are new inline annotations in the editor. Bookmarks and Clang errors and warnings are now also shown at the end of the corresponding text line in the editor. This way, you can easily see the details of issues while you type, without the need to hover your mouse over underlined text or the marker on the left side. You can configure the position of the annotations in the Options > Text Editor > Display. (You can also turn the feature off there, if you don’t like it.)

We also added the option to smoothly scroll to the new location if you jump to a different place in the same file. If you like to try this feature, turn it on in Options > Text Editor > Display > Animate navigation within file.

C++

We enabled some highlighting features that were already available, but didn’t have their own color set in the default color scheme. Local, global and member variables, functions, declarations and output arguments are now distinguishable by their highlighting in the editor. In case that is too colorful for you, we made the more modest previous scheme available as Default Classic in Options > Text Editor > Fonts & Colors.

When you rename a class, Qt Creator now offers to rename files with the same base name as well. Just check the Rename files option in the search result panel before pressing the Replace button.

If you have the Clang code model enabled, this is now also used for the highlighting of the identifier at the text cursor, which was previously still using the built-in model in any case.

CMake

Qt Creator CMake project treeWe did some cleanup of the project tree when using CMake >= 3.7 (“server-mode”). It now defaults to hide empty directories, and the source files moved one level up, getting rid of the additional <Source Directory> node. We also fixed the application’s working directory when a CMAKE_RUNTIME_OUTPUT_DIRECTORY is specified, and that it was not possible to accept external changes from the CMake configuration has changed on disk dialog.

Other changes

We removed the unmaintained support for Windows CE, and changed the ClearCase integration to be disabled by default.

This is just a small selection of the changes and improvements done in 4.4. Please have a look at our change log for a more detailed overview.

Get Qt Creator 4.4.0

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.4.0 is also available through an update in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

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

QtLocation 5.9

With Qt 5.9, the QtLocation module has received a substantial amount of new features, as briefly summarized in the release post. The goal of this post is to provide additional details about what’s now possible with QtLocation 5.9.

Rotating and tilting maps

One long-standing limitation of the built-in tile renderer was the inability to draw rotated or tilted maps and map items. We finally removed this limitation, and in 5.9 maps as well as the map items added to them can be rotated and tilted. This also applies to MapQuickItems, which can be tilted by setting the appropriate zoomLevel value to them. With the support for tilting and rotation come two new dedicated gestures in the gesture area of the map: two fingers rotation, and two fingers vertical drag for tilting.

It is now possible to rotate and tilt maps. Items on it will be transformed accordingly. In this figure a MapQuickItem embedding a QtMultimedia Video element is used to overlay a video of the shore.

It is now possible to rotate and tilt maps. Items on it will be transformed accordingly. In this figure a MapQuickItem embedding a QtMultimedia Video element is used to overlay a video of the shore.

In addition to this, a new fieldOfView property has been added to the Map, to control the camera field of view when the map is tilted. Note that this property, like the tilt and the zoomLevel properties, have lower and upper bounds. In some cases these bounds will prevent changing the property (e.g., a plug-in using a third-party renderer that does not allow changing the field of view will return a lower bound for the field of view equal to the upper bound).

Tile overzooming

Another long-standing limitation that got us many complaints over the last years was the inability of using cached data to approximate tile content not yet provisioned.
Lower zoom level tiles are now used to approximate higher zoom levels tiles, until these are fully provisioned. This finally prevents, where possible, the appearance of empty tiles revealing the (usually gray) background.

The difference in loading the map tiles, 5.8 (top) vs 5.9 (bottom)

The difference in loading the map tiles, 5.8 (top) vs 5.9 (bottom)

Improved third party map renderer support and the MapboxGL plugin

Prior to 5.9, the only way to display a map using QtLocation was to cut it into raster tiles, and feed the tiles to the built in tiled map renderer. Some have created plug-ins that embedded third party map renderer, but in the end they all had to do the rasterization-to-tiles step, in order to get the map on the screen.

QtLocation 5.9 removes this roadblock, allowing to draw custom QSG nodes in a custom QGeoMap implementation, so that it is finally possible to plug a third party renderer directly into the QtQuick scene graph.
This can be done in different ways, the most common being rendering the map off-screen into a texture, and then rendering the texture in the QtQuick scene graph, or using a QSGRenderNode to issue graphics commands directly.
The second approach is more efficient, but also more complex to set up and with more corner cases to handle.

How this performs can be seen by trying out the new Mapbox GL plugin, that, in cooperation with Mapbox, has been included in Qt for most of the supported platforms. This plug-in renders Mapbox Vector Tiles using the mapbox-gl-native renderer, supporting both online and offline map sources. This plug-in also allows to select either of the two rendering approaches mentioned above (although it should be noted that the QSGRenderNode approach is experimental and may introduce problems).

The MapboxGL plugin in action

The MapboxGL plugin in action

Handing map items rendering over to the plug-in

In addition to handing the map rendering over to the plug-in, it is also possible for a QGeoMap implementation to define which types of map items it can to render by itself. With QtLocation 5.9, if a plug-in instantiates a QGeoMap that reports the ability of drawing MapPolylines, these items are handed over to the plug-in, and the default rendering path for items of that type will be disabled. They will behave just like before, but their visual appearance will depend entirely on how the plug-in renders them. The MapboxGL plugin can, for example, render native MapRectangles, MapCircles, MapPolylines and MapPolygons. They will be anti-aliased and their style can be customized using Mapbox style specifications.
On the downside, the rendering of these items entirely depends on the plugin. So, on a MapboxGL map for example, they not support borders, so setting border properties on the items will have no effect. They also do not currently support visiblity and opacity for the items, although this is something that may get fixed very soon.

MapPolyline rendered on a map using the MapboxGL plugin. The polyline has been styled using MapParameters

A MapPolyline rendered on a map using the MapboxGL plugin. The polyline has been styled using MapParameters

Exposing Plug-in – specific mapping features

Enabling the integration of third-party mapping engines opens up for the opportunity of using features that are specific to the one or the other engine. For example, the mapbox-gl-native library offers a very flexible API for changing the style of map elements at runtime.
To allow plugins to expose engine-specific features, we have introduced a new QML type, MapParameter. Elements of type MapParameter are essentially duck-typed, as properties have to be defined by the programmer according to what the documentation of the plug-in requires. In the case of the Mapbox GL plugin, a map parameter to control the visibility of a Mapbox style layer named “road-label-small” would look like this:

MapParameter {
    type: "layout"
    property var layer: "road-label-small"
    property var visibility: "none"
}

Note that properties in map parameters are dynamic. They can be changed at runtime and the effects will be immediate.

Improved stacking of multiple Maps

Combining multiple map layers has been challenging with the previous Qt releases. That’s because different Map elements would have different zoom level ranges, and these ranges would also be enforced. In addition, map copyright notices could only be turned on or off, with the result of having them overlapping on screen.
In 5.9 the Map element allows the zoomLevel property to go beyond the minimum or maximum supported zoom levels, if set programmatically (that is, not through mouse or gestures interaction) and the used plug-in supports overzooming.
This way it is possible to use property bindings on the zoomLevel property of all the overlay maps to be driven by the value in a base map “layer”.

In addition, it is now possible to manually add elements of type MapCopyrightNotice on top of the maps, and source their content from the map elements. In this way they can be freely arranged, and also styled using custom CSS code.

Finally, one problem that was previously common when changing maps at runtime was that map items added to a map would be gone when the map would be replaced with another map sourced from a different plug-in.
For this reason, we include a new plug-in called itemsoverlay, whose only purpose is to provide a completely empty, transparent, map that costs almost nothing to render. The intended use is to have one Map element using this plug-in on top of the map stack, where to keep map items, so that the layers underneath can be freely removed.

Other improvements

A new method, fitViewportToVisibleMapItems, has been added to the Map element, to only consider visible items when fitting the viewport. A new QML type, MapItemGroup, has been introduced, to combine multiple map items together, like in a separate qml file. Note that it is currently not possible to use MapItemGroups in combination with MapItemViews.

The post QtLocation 5.9 appeared first on Qt Blog.