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

I'm delighted to announce that I just released qutebrowser v1.0.0!

qutebrowser is a keyboard driven browser with a vim-like, minimalistic interface. It's written using PyQt and cross-platform.

This release comes with many big breaking changes such as the new config and QtWebEngine by default, so please take a look at the changelog.

As announced previously, per-domain settings unfortunately didn't make it into v1.0.0 - it's the next thing I plan on tackling. However, there's more than enough big things in v1.0.0! :)

Enjoy!

The full changelog for this release:

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.

From Qt 5.10 on, there is a new way how to start detached processes with QProcess.

Of course you know this, but let me quickly repeat what a detached process is. If you start a program using QProcess without detaching, then the destructor of QProcess will terminate the process. In contrast, a detached process keeps running unaffected when the calling process exits. On Unix, a detached process will run in its own session and act like a daemon.

Traditionally, we start detached processes with the static QProcess::startDetached() method.

QProcess::startDetached("aplay tada.wav");


There is a second overload that supports passing a separate argument list and the working directory. It also lets us retrieve the PID of the started process.

qint64 pid;
QProcess::startDetached("mpg123", {"Jeopardy_Theme.mp3"}, musicDirPath, &pid);
printf("Performing a lengthy calculation...");
calculateDeterminant(reallyBigMatrix);
puts("done.");
QProcess::startDetached("kill", {QString::number(pid)});


This little example crunches numbers for a while and plays the Jeopardy Theme to entertain the user. When the calculation result is ready, it kills the music player using the obtained PID.

When running this example on Linux, you will notice a little annoyance: we have no way of suppressing the output of the detached process.
(Okay, this particular tool has the “–quiet” option, but let’s ignore that for the example’s sake.)

Qt Users have requested for a long long time the ability to

• set the process environment,
• redirect stdin, stdout, stderr to files
• and set native arguments and the CreateProcess argument modifier on Windows

for detached processes.

All this is now possible in Qt 5.10! But instead of adding a monstrous overload for the static startDetached() method, we added a non-static QProcess::startDetached(qint64 *pid). This new member function reads the properties of your QProcess object and starts the to-be-detached process accordingly. It can be used as follows:

QProcess process;
process.setProgram("mpg123");
process.setArguments({"Jeopardy_Theme.mp3"});
process.setWorkingDirectory(musicDirPath);
process.setStandardOutputFile(QProcess::nullDevice());
process.setStandardErrorFile(QProcess::nullDevice());
qint64 pid;
process.startDetached(&pid);
...


The redirection to /dev/null makes sure that the user is not disturbed by visual output of the audio player.

Only a certain sensible subset of functions is supported for startDetached():

• setArguments()
• setCreateProcessArgumentsModifier()
• setNativeArguments()
• setProcessEnvironment()
• setProgram()
• setStandardErrorFile()
• setStandardInputFile()
• setStandardOutputFile()
• setWorkingDirectory()

All other properties of the QProcess object are ignored.

If there are more properties to be supported in the future, they can be easily added in the implementation of the new startDetached().

Happy detaching!

The post A new QProcess::startDetached appeared first on Qt Blog.

V-Play 2.13.0 adds rewarded videos and native ads as two more ad types to the free AdMob Plugin. This allows you to better monetize your app or game and enables you to earn more revenue from your app! This update also adds support to get the phone contact list on Android & iOS and to get the phone number of the user’s mobile device.

Rewarded Videos

The new AdMobRewardedVideo component allows you to reward users for watching a full-screen interstitial ad in full length. The ad is either a skippable video or an interactive ad.

You can choose how this reward looks like: give away some virtual currency, virtual items or unlock features within your app or game are popular examples. Here is an example how you can give the user virtual currency:

import VPlay 2.0
import VPlayPlugins 1.0
import QtQuick 2.0

Item {

  // start currency
  property int currency: 20

  AdMobRewardedVideo {
    id: myRewardedVideo

    // test ad for rewarded videos
    adUnitId: "ca-app-pub-3940256099942544/5224354917"

    onRewardedVideoRewarded: {
      currency += 10
    }

    // load interstitial at app start to cache it
    Component.onCompleted: {
      loadRewardedVideo()
    }

  }

  ButtonVPlay {
    text: "Simulate Level Completed"
    onClicked: {
      // each level "costs" 1 currency
      currency--

      if(currency < 10) {
        // show the new video if user is below 10 credits
        myRewardedVideo.showRewardedVideoIfLoaded()

        // load a new video every time it got shown, to give the user a fresh ad
        myRewardedVideo.loadRewardedVideo()
      }
    }
  }

  ButtonVPlay {
    text: "Simulate In-app purchase 1000 Credits"
    onClicked: currency += 1000
  }

}

With this example code, you can motivate users to watch an ad because they get something for it. Those users who do not want to watch an ad, can also purchase a virtual currency with the above code example. By only showing the ad if the user is below a certain virtual currency threshold, you guarantee users who bought a virtual currency pack do not see the ad.

We have this mechanism in place in the popular One Card game– you can use its full source code and copy it to your app. This also includes a real in-app purchase implementation with our free in-app purchase plugin.

Why and When to Use Rewarded Ads

Rewarded ads are the preferred way to use mobile ads these days, so we highly recommend to use this feature in your apps. The perfect time to show a rewarded ad is when a user navigates between pages or screens of your app. For example after he finished a game or after he had a “success moment” like completing a level. You could motivate the user even more to watch an ad by giving extra benefits after such a success moment. This helps you to earn money, while on the other hand giving a benefit to the user – a win-win situation.

The AdMobRewardedVideo component is part of the free AdMob plugin. See here how to add the AdMob plugin into your app.

Native Ads

You can now use native ads with the new AdMobNative component for the Google AdMob Plugin. Native banner ads are a more flexible way to show ad banners. They can have any position, width, height, color and text placement so you can better fit them into your user interface. You can even use them for example as list items in a ListView, like Facebook is doing this in the user timeline of their mobile app.

There are three different template types (small, medium and large) to select from. Each of the template types have different ranges for their size, for example a small ad must have a height of at least dp(80).

For complete control over the appearance, you can customize the CSS code. If you do not want to write any CSS on your own, the templates can be used as they are and their styling can be customized in the AdMob backend with a visual ad template editor. In the template editor, you can choose various colors for the template and preview it for specific sizes:

In comparison to standard banner ads, native ads require a little bit more work to setup, but have a much better user experience because the ad blends into your app’s user interface.

Supported Ad Types of the Google AdMob Plugin

With these 2 new ad types, you can now use ALL of the available ads from Google AdMob: banner ads, full-screen interstitial ads, rewarded videos and native ads:

All of these ad types are part of the V-Play AdMob Plugin. See here how to add the V-Play plugin to your app or game. The AdMob Plugin is available for free for all V-Play developers!

If you have an existing Qt app/game and would like to add the AdMob plugin but no other V-Play components, you can find a guide how to add the AdMob plugin to your Qt based app here.

Get Contact List and Phone Numbers on iOS & Android

With this update, you are able to get the mobile device’s contact list on iOS & Android with a single call to NativeUtils::getContacts(). This allows you to create a messenger app like WhatsApp, where users can see who of their contacts also use your app.

Here is an example how to display all contacts in a list:

import VPlayApps 1.0

App {
  AppListView {
    anchors.fill: parent
    model: nativeUtils.getContacts()

    delegate: SimpleRow {
      text: modelData.name
      detailText: modelData.phoneNumber
    }
  }
}

And this is how the above code looks like on iOS:

More Fixes & Improvements

Besides the highlights mentioned above, there are many other fixes and improvements for the SDK. 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.

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!

Important Notice for Windows Developers

Follow these steps on Windows, because otherwise you will not be able to use the new features of this update but still are on the previous V-Play version 2.12.2. 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.

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

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:

More Posts Like This

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

Release 2.11.0: All Monetization Plugins Now Free, Plugin Trial & Firebase Qt Plugin

WeAreDevelopers Conference App – Open Source & Live Now!

The post Release 2.13.0: Free Rewarded Videos & Native Ads for Google AdMob and Qt appeared first on V-Play Engine.

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.

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

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!

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 and video and still image shooting.

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.

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.

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.

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:

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.

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

QtQuick is a popular choice for creating HMIs for embedded devices. The hardware on these devices is often constrained and less performant than their desktop equivalents, this requires extra care from software developers in delivering a fluid user experience. KDAB is regularly involved in improving the performance of QtQuick HMIs on such devices for their customers.

In this demonstration, we will show how to profile and optimize the performance of a QtQuick speedometer, an example taken from an actual embedded project running on an i.MX6 board. We will demonstrate how to identify the performance bottleneck with the QML profiler in QtCreator,pointing out possible solutions and then choosing the best one.

Voice by Wieland Hagen. continue reading

The post Profiling QtQuick HMI Performance on Embedded Linux appeared first on KDAB.

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.

The Qt World Summit 2017 featured great keynote speakers, #BuiltwithQt customer keynotes and sessions on a wide range of inspiring topics and here are the recordings and the photo gallery from this year’s biggest Qt event made available for easy and fast viewing.

Qt World Summit sold out this year and for those of you who couldn’t get a ticket, want to re-live the experience or simply could not be at two sessions you were interested in, running simultaneously (quite challenging to do), we have made all the recordings available.

Keynotes

Get inspired by our keynote speakers from this year’s event and watch recordings from:

• Juha Varelius, CEO of The Qt Company opening the show and providing some insight on why Qt has so much potential and relevance in our everyday life.
• Lars Knoll, Chief Maintainer of Qt and CTO of The Qt Company discussing the current and next steps of where Qt is going
• Herb Sutter, Leading C++ authority and chair of the ISO C++ standards committee, talked about recent and relevant topics in the C++ world.
• Linda Liukas, Programmer, Storyteller and children’s book author who spoke about how we can move towards a more humane tech industry
• Dr. Steven Goldfarb from the CERN ATLAS experiment who talked about how to answer the most profound questions humanity has
• Igor Beuker, Entrepreneur & Trendwatcher and his take on the trends in software, how businesses need to switch their mindset and how the “Math Men” are knocking the socks off the “Mad Men” in the world of today’s business.

#BuiltwithQt Customer Keynotes

Qt is truly everywhere and used in a large variety of industries and use cases. This year’s event featured customer keynotes from leading brands within the gaming industry, consumer electronics, cancer research and automotive customers who all build with Qt. Take a look:

• Daimler: Behind the scenes of a show car: Rapid UI/UX prototyping and production by Alex Hilliger, Senior Manager Advanced Graphics and rendering
• Panasonic ITS: The Future of Vehicle HMI Systems by Takayuki Tanabe, CEO, Development Center Chief
• Hasselblad: Using Qt to Build Next Generation Intuitive High-End Cameras by Richard Röjfors, Senior Developer
• Quantitative Imaging Systems: The Next Frontier in Battling Cancer by Michel Nederlof, CEO
• Amazon Lumberyard: Game Engine Evolution: From Tech to UX by Alex Montgomery, Game Engine Tools Specialist
• Qualcomm:  An Integrated Development Environment (IDE) for Embedded Devices by Justin Howard, Senior Staff

Sessions & Tracks

Qt World Summit has something for everyone we split all our sessions into tracks. Check out the recordings based on the track that interests you the most:

• Application Development
• Embedded
• Graphics and 3D
• Technical Deep Dive
• Automotive
• Automation
• Medical
• Business

With that I hope you will enjoy watching the videos and share the link with your peers!

The post Qt World Summit 2017 Recordings appeared first on Qt Blog.

V-Play 2.13.2 adds support for Qt Creator 4.4.1 and Qt 5.9.2 which fixes Android deployment issues with the latest Android SDK (Android Oreo) and NDK versions and adds support for iOS 11.

It also stores your previous window position and size to accelerate the development process and adds many bug fixes and improvements.

Qt 5.9.2 & Qt Creator 4.4.1 Support

The latest stable Qt and Qt Creator versions provide many bug fixes and improvements. The most relevant change is a fix for building Android projects with ndk r16 and higher and supporting Android tools in Android SDK versions 26.1.1 and higher.

Thanks to the internal installation changes we rolled out with V-Play 2.13.0 and 2.13.1, you do not need to manually update the Qt version any longer. Instead, this update will automatically update the Qt version for you for Desktop platforms.

iOS 11 & Android Oreo Support

If you have the Android or iOS platforms installed, please make sure to follow these steps:

1. Perform the V-Play Update by running the MaintenanceTool in the V-Play SDK directory and select “Update Components”.
   
2. After the update, open the MaintenanceTool again and Select the “Add or remove components“ option
   
3. Add the Qt 5.9.2 packages for Android and iOS. This image shows the initial state before you seleced Qt 5.9.2:

   Add the Qt 5.9.2 packages for Android and iOS. iOS is not listed in this screenshot as it is not available on Windows. Unselect the Qt 5.9 package like shown in this image:

4. In Qt Creator, choose the new kit for Android and iOS based on Qt 5.9.2.

If you are using V-Play Plugins, additionally follow the steps described here. See here how to update your project to support iOS 11.

We will simplify the update process for iOS & Android builds with one of the next updates. So these steps will be done automatically for you just like it is now for Windows, Mac and Linux.

Restore Last Window Position

With this V-Play release, the last window position & size is automatically stored on Desktop platforms (Windows, Mac & Linux) during development when you close your app or game. At the following app start, this last position and width/height settings are then restored.

This accelerates the development process, because you save the time of re-positioning and re-sizing the window to your last setting. This feature is enabled by default for development builds. It is disabled for publish builds – you can enable publish builds by modifying the config.json as explained here. You can also manually enable and disable this new feature with the storeWindowGeometry property.

More Fixes & Improvements

Here is a shortened list of other fixes & improvements in this release:

• Fix popping pages from the NavigationStack with the Android back button. Before, PageControl::previousPage and Page::isCurrentStackPage were not properly set with back button navigation.
• If the user currently has no internet connection and sends a chat message with the V-Play Chat, store it locally in a database so it gets sent as soon as internet connection is available again.
• Add description how to set up Push Notification entitlement for iOS to the OneSignal and Google Cloud MessagingiOS integration guides.
  
• Fix VPlayGameNetwork issues: automatically detecting locale & country and storing a country manually in the ProfileView now works more reliably.

Besides the highlights mentioned above, there are many other fixes and improvements for the SDK. 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.

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 iOS & Android developers, follow the steps explained above.

More Posts Like This

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

The post Release 2.13.2: Update to Qt 5.9.2 & Qt Creator 4.4.1 | Android Oreo & iOS 11 Fixes & Many Improvements appeared first on V-Play Engine.

About a month ago I started exercising more, mostly jogging, weights and soccer (with kids). Target is to be in superb shape when 2018 starts, and I'm already feeling stronger & more energetic during the day so looking good!

Anyway, this blog post is somewhat related to that. There's plenty of health-related apps and gadgets available these days and in the past I used some time pondering what would be a perfect activity tracking app for my needs. Now I decided to revive this earlier concept as 'FitGraph NG' while porting it to use QNanoPainter and polishing some parts.

As usual, let's start with a video demonstrating the actual application:

• Showing the whole day as a graph, data or textually depending on needs.
• Automatic annotation of activities, type, duration and related activity data. And importantly, being able to select each activity to cover only data during that.
• See how well you have reached your 'moves' goal which would come from all your activities.
• Also collect other notes, goals, concerns etc. during the day.

• Implemented with Qt, so cross-platform on Android, iOS etc. Application logic C++ and UI naturally QML with few shaders.
• Graphs are painted with single QNanoPainter item for efficiency. Graph animations are driven from QML side for easy tuning.
• Data is managed with SQLite and fetched into QAbstractListModel. There's configurable QCache to reduce SQL queries. Data in this prototype is generated dummy, but basically allows "unlimited" scrolling of days.
• Performance was important target, some tricks and optimizations were required to get application working fluidly at 60fps also on lower end Android devices. 

Cutelyst the Qt Web Framework got a new release, another round of bug fixes and this time increased unit testing coverage.

RoleACL plugin is a very useful one, it was written due the need for controlling what users could access, sadly the system I wrote that needed this got unused (although I got my money for this) so this plugin didn't get much attention, partially because it was basically complete.

Then last release I added documentation to it due a user's request and shortly after I found out that it wasn't working at all, even worse it wasn't forbidding users like it should do. So after the fix I moved on writing unit test for many other stuff. There's still missing stuff but overall coverage is much larger now.

Enjoy https://github.com/cutelyst/cutelyst/archive/v1.10.0.tar.gz

During the last week of September I attended the 2017 edition of CppCon, in Bellevue, WA. Unusually late due to my presence at Qt World Summit which took place just after it, here's my trip report.

continue reading

The post CppCon 2017: trip report appeared first on KDAB.

The Qt World Summit recordings 2017 are online. basysKom presented “Practical Qt Lite”. Qt Lite is a project within Qt geared towards optimizing Qt for smaller devices. One important feature of the overall Qt Lite story is the ability to create size optimized, application specific builds of Qt. These require less flash, less RAM and …Continue reading QtWs17: Practical Qt Lite

Hi everyone!

Here’s an overview of our free webinars we will be holding in the upcoming weeks. They usually take place at 6pm CET, 1pm EDT and 10am PDT so you can participate live and ask our experts any questions you may have.

Don’t have the time to participate live? Sign up anyway – we will send you a recording and the presentation slides to your email address!

8 November: Accelerating time to market for embedded devices
Join our webinar where we’ll go through solutions for tackling the most common issues in executing a large-scale software program. The learnings are mainly based on the extensive experience with embedded customers over the years.

16 November: Ask Me Anything about graphics in Qt

In this Ask Me Anything about graphics in Qt, we are putting you in the driving seat. Our smart and handsome graphics specialists, Andy Nichols and Laszlo Agocs will answer your questions live.

23 November: Qt or HTML5 – A Million Dollar Question

Burkhard Stubert explains how he could save one of the world’s largest home appliance manufacturers millions of Euros by choosing Qt over HTML. The secret? Qt scales down to lower-end hardware a lot better, without sacrificing user experience.

7 December: Pointer Handlers for Fluid Applications in Qt Quick
Over the last few years we have discussed adding a new way in QtQuick to handle events from pointing devices such as touchscreens, mice and graphics tablets. Now it is on track to ship in 5.10. This is an update and demo of the current status.

14 December: An Interactive Digital Out-of-Home Software Developed by Using Qt Libraries

This webinar will explore the different features of the interactive DOOH software and underline the integration of the Qt libraries within the software.

Missed a webinar such as our hilarious Halloween special? No problem! You can find recordings of all our webinars in the on-demand section! Download them and get smart!

The post Upcoming webinars: Sign up Now! appeared first on Qt Blog.

I spoke at the ACCU conference in April 2017 on the topic of Embracing Modern CMake. The talk was very well attended and received, but was unfortunately not recorded at the event. In September I gave the talk again at the Dublin C++ User Group, so that it could be recorded for the internet.

The slides are available here. The intention of the talk was to present a ‘gathered opinion’ about what Modern CMake is and how it should be written. I got a lot of input from CMake users on reddit which informed some of the content of the talk.

Much of the information about how to write Modern CMake is available in the CMake documentation, and there are many presentations these days advocating the use of modern patterns and commands, discouraging use of older commands. Two other talks from this year that I’m aware of and which are popular are:

• Daniel Pfeifer “Effective CMake”
• Mathieu Ropert “Using Modern CMake Patterns to Enforce a Good Modular Design”

It’s very pleasing to see so many well-received and informative talks about something that I worked so hard on designing (together with Brad King) and implementing so many years ago.

One of the points which I tried to labor a bit in my talk was just how old ‘Modern’ CMake is. I recently was asked in private email about the origin and definition of the term, so I’ll try to reproduce that information here.

I coined the term “Modern CMake” while preparing for Meeting C++ 2013, where I presented on the topic and the developments in CMake in the preceding years. Unfortunately (this happens to me a lot with CMake), the talk was not recorded, but I wrote a blog post with the slides and content. The slides are no longer on the KDAB website, but can be found here. Then already in 2013, the simple example with Qt shows the essence of Modern CMake:


find_package(Qt5Widgets 5.2 REQUIRED)

add_executable(myapp main.cpp)
target_link_libraries(myapp Qt5::Widgets)


Indeed, the first terse attempt at a definition of “Modern CMake” and first public appearance of the term with its current meaning was when I referred to it as approximately “CMake with usage requirements”. That’s when the term gained a capitalized ‘M’ and its current meaning and then started to gain traction.

The first usage I found of “Modern CMake” in private correspondence was March 13 2012 in an email exchange with Alex Neundorf about presenting together on the topic at a KDE conference:

Hi Alex

Are you planning on going to Talinn for Akademy this year? I was thinking about sumitting a talk along the lines of Qt5, KF5, CMake (possibly along the lines of the discussion of ‘modern CMake’ we had before with Clinton, and what KDE CMake files could look like as a result).

I thought maybe we should coordinate so either we don’t submit overlapping proposals, or we can submit a joint talk.

Thanks,

Steve.

The “discussion with Clinton” was probably this thread and the corresponding thread on the cmake mailing list where I started to become involved in what would become Modern CMake over the following years.

The talk was unfortunately not accepted to the conference, but here’s the submission:

Speakers: Stephen Kelly, Alexander Neundorf
Title: CMake in 2012 – Modernizing CMake usage in Qt5 and KDE Frameworks 5
Duration: 45 minutes

KDE Frameworks 5 (KF5) will mark the start of a new chapter in the history of KDE and of the KDE platform. Starting from a desire to make our developments more easy to use by 3rd parties and ‘Qt-only’ developers, the effort to create KF5 is partly one of embracing and extending upstreams to satisfy the needs of the KDE Platform, to enable a broadening of the user base of our technology.

As it is one of our most important upstreams, and as the tool we use to build our software, KDE relies on CMake to provide a high standard of quality and features. Throughout KDE 4 times, KDE has added extensions to CMake which we consider useful to all developers using Qt and C++. To the extent possible, we are adding those features upstream to CMake. Together with those features, we are providing feedback from 6 years of experience with CMake to ensure it continues to deliver an even more awesome build experience for at least the next 6 years. Qt5 and KF5 will work together with CMake in ways that were not possible in KDE 4 times.

The presentation will discuss the various aspects of the KDE buildsystem planned for KF5, both hidden and visible to the developer. These aspects will include the CMake automoc feature, the role of CMake configuration files, and how a target orientated and consistency driven approach could change how CMake will be used in the future.

There is a lot to recognize there in what has since come to pass and become common in Modern CMake usage, in particular the “target orientated and consistency driven approach” which is the core characteristic of Modern CMake.

When implementing component into QtQuick UI which needs something more than rectangles, images and texts, pure declarative QML hasn't been enough. Popular choices to use for items with some sort of vector drawing are QML Canvas, QQuickPaintedItem or QNanoPainter.

But with Qt 5.10 there will be supports for new Shape element with paths that contain lines, quads, arcs etc. so I decided to install Qt 5.10 beta3 and implement all tests of "qnanopainter_vs_qpainter_demo" with also QML + Shape elements. (This kinda makes it "qnanopainter_vs_qpainter_vs_qmlshape_demo" but not renaming now). So here is in all glory the same UI implemented with QNanoPainter (left), QQuickPaintedItem (center), and QML+Shape (right):