Note that throughout this blog post, the term “Apple Platforms” will be used to refer to all four Apple operating systems (macOS, iOS, tvOS, and watchOS) as a whole.

I thought it would be a good time to share some of the highlights of what’s new in Qt on Apple Platforms with the recent release of Qt 5.8.

New Platforms

To start off, Qt now has Technology Preview level support for Apple TV and Apple Watch devices beginning in Qt 5.8. This completes our offering to support all four Apple Platforms – macOS, iOS, tvOS, and watchOS.

tvOS (Apple TV)

Qt for tvOS is 95% similar to iOS (even the UI framework is also UIKit) and as a result, contains roughly the same feature set and supported modules as iOS, with the notable exception of QtWebEngine.

The major difference between the two platforms is input handling. iOS has a touch-based model that maps fairly well to a traditional point and click desktop interface from a programming perspective, while tvOS has a focus based model. This means that you don’t have a canvas which can receive input at a particular point (x,y coordinate), but rather an abstract canvas in which you “move” the focus to a particular object. When an object has focus, you can use the Apple TV Remote to trigger an action by clicking its trackpad or pressing the Menu or Play/Pause buttons.

Qt supports some aspects of the tvOS input model (scrolling and clicking are recognized), but there will be some degree of manual work handling input events in QML to build a tvOS app. Most basic navigation actions on the Apple TV Remote are exposed as keyboard events in Qt, and gesture recognizers can be used for more complex multitouch input. We are still exploring ways to provide mechanisms that make it easier to work with this new input model.

We’d also like to thank Mike Krus doing the initial work of porting Qt to tvOS, and who is now the platform’s maintainer.

watchOS (Apple Watch)

Qt for watchOS is also heavily based on iOS. However, it is not possible to run QML or any other Qt based UI on the watch using public APIs because the primary interface API is WatchKit (as opposed to UIKit). Therefore, Qt can currently only be used for non-UI tasks such as networking, audio, backend graphics processing, etc. If the available watchOS APIs change in the future then we can certainly explore the possibilities at that point.

I am also the watchOS platform maintainer, so please feel free to send me any questions or feedback.

Shared Libraries on iOS

Only static libraries were permitted for most of iOS’s existence, as many iOS developers are no doubt aware. Apple’s App Store requirements prohibited shared libraries even though the underlying operating system supported them since 1.0. Finally, with the release of iOS 8 and Xcode 6 in 2014, shared libraries/frameworks became officially supported by Apple for use in applications submitted to the App Store. Unfortunately, while this feature did not make it in time for the Qt 5.8 release… Qt 5.9 will support them too (also for tvOS and watchOS)!

To build Qt as shared libraries on iOS, all you need to do is pass the -shared option to configure (and this will be the default in the next release). Note that shared libraries require a deployment target of at least iOS 8.0, which will also be the minimum requirement for Qt 5.9.

With shared libraries, you can simplify your development workflow by not having to maintain separate code paths for static libraries on iOS and shared libraries on other platforms. Shared libraries also allow you to:

• When using App Extensions (as both your main application and your extension executables may link to the same copy of the Qt frameworks), reduce memory consumption and reduce disk space consumption on your users’ devices as your app will be smaller
• Make your code base easier to maintain through strict API boundaries and the benefits of namespacing
• Speed up linking and thus overall build time

Because the question will inevitably come up: we do not believe shared libraries will have any practical effect for LGPL users. There are other concerns that come into play with the Apple App Store (namely, DRM) which render the point moot. However, we recommend using shared libraries for the technical reasons outlined above. And as always, seek professional legal advice with regard to software licensing matters.

Build System Enhancements

In the past several Qt releases we have also made a number of significant enhancements to the build system on Apple Platforms, including:

• @rpath in the install names of Qt libraries, providing relocatability out of the box (Qt 5.5)
• Standalone .dSYM debug symbols (Qt 5.6.1, Qt 5.6.2)
• Building asset catalogs (Qt 5.6.3 & Qt 5.7.1)
• Bitcode on iOS which allows Qt applications to take advantage of App Thinning (Qt 5.8)
• Precompiled headers on iOS, tvOS, and watchOS, reducing build time by up to 30% (Qt 5.8)
• Combined simulator and device builds, doing away with the confusing separate _simulator libraries on iOS (Qt 5.8)
• Multi-arch (“universal”) builds on macOS, back from Qt 4.x (coming in Qt 5.9)
• Automatically embedding Qt frameworks within a Qt app bundle in qmake-generated Xcode projects (coming in Qt 5.9)
• …and many other smaller bug fixes

One more thing… we’ve been changing every reference to “Mac OS X” and “OS X” that we can find into “macOS”. 🙂

The post What’s New in Qt on Apple Platforms appeared first on Qt Blog.

Android Things is Google’s answer to creating an environment for IoT devices. Take a slimmed down Android build, add some sensor-specific APIs, and provide it on a number of powerful pre-integrated micro-boards and you have a ready-made platform for building a host of upcoming IoT devices. Android Things can take advantage of many existing Android libraries, toolkits, and APIs, making it easier and quicker for developers to turn ideas into product. What’s not to like?

We decided to test this theory by checking out the Android Things Developer Preview on a Raspberry Pi 3. We were looking to assess the overall experience, to understand what types of products it is targeting and to try to determine how well it can support Qt.

One of my very first observations is that Google does not provide the source, just a pre-built image. This makes it difficult to customize the image and puts us at the mercy of Google for updates to any of the contained components or packages like the kernel or SSL library. Let’s hope that this will change once we’re beyond the Developer Preview stage.

Once you have the image loaded onto a board, it’s time to boot it and take it for a spin. This is an appropriate time to get a coffee — and you’ve got the time to drive to Starbucks — because booting Android Things takes a very long time. Linux builds for Yocto or Debian on the same hardware boot significantly faster than Android Things, so we can probably assume the boot process hasn’t yet been fine-tuned. Without knowing the final boot speed of an Android Things product, you may want to plan use cases around a system that’s always on and rarely needs a reboot, or that isn’t real-time and can afford a boot process that takes minutes.

The Android Things Preview on the Raspberry Pi 3 doesn’t provide OpenGL ES support or a virtual keyboard, which severely limits what type of Android Java apps will run. (Unfortunately, that also means it cannot support Qt QML either.) It’s pretty safe to say that if your device plans to have a full smartphone-like display, you might not want to use Android Things anyway. Although it does support frame buffer graphics, without hardware acceleration the graphics are quite pokey. Our guess is that even if Android Things will eventually support OpenGL ES, its best application will be for a headless configuration or one where your display needs aren’t too sophisticated.

Unfortunately, boot speed and graphics aren’t the only things that are sluggish. Running and installing apps are quite slow: first time loads for a Java app are around 20 seconds, and for a Qt app around 25 seconds. This delay is likely due to the AOT compiler, because things speed up dramatically to a boot in just 2-3 seconds on subsequent loads. While this is a pain for developers who will suffer these load times for each new build, the AOT compiling means that customers would only notice a slow experience first time out-of-the-box.

Now for the good news. Qt developers will be happy to know that Qt Creator works very well with Android Things — running and debugging apps just works. And not only will QWidget-based applications run on Android Things, they’re even faster than the platform’s native Android Java widgets. This may not be saying much without GPU-accelerated graphics but any speed improvement is a bonus.

Also good news is the device’s security. Android Things uses the Android security/permissions model across the board, letting you have complete security control of your IoT device access, and placing all apps in isolated containers by default. With IoT security being a primary concern, built-in security from the ground up is most welcome.

Finally, Android Things is Apache 2 licensed. People who are building an IoT device to be sold as a product will appreciate that they don’t have to open up their source code to the world. It is a disadvantage to those who are tinkering but this choice (and the Google source ownership) pretty clearly point to a commercial product bias.

Conclusion

If you’re an Android fan, you’ll like where Android Things is going. It’s a bit on the slow side, as it’s clearly designed with certain use cases in mind — like little (or no) display and infrequent reboots — but the benefits of Android development may outweigh the disadvantage of carrying around a massive Android runtime. It will definitely suffer on low-end devices but we can hope that optimizations will be made as more programmers get their hands on it. We’ll certainly be keeping our eyes on it and, as running C++ can do nothing but help the overall speed, we’ll be trying to make sure that it supports Qt as best as possible.

The post “Unboxing” the Android Things Developer Preview appeared first on KDAB.

In this article, I will take a look at one of the fundamental concepts introduced in Alex Stepanov and Paul McJones’ seminal book “Elements of Programming” (EoP for short) — that of a (Semi-)Regular Type and Partially-Formed State.

Using these, I shall try to derive rules for C++ implementations of what are commonly called “value types”, focusing on the bare essentials, as I feel they have not been addressed in sufficient depth up to now: Special Member Functions.

Alex Stepanov and Paul McJones gave us a whole new way of looking at this, with a mathematical theory of types and algorithms quite unlike anything ever done before. Their achievement will forever change the way you look at computer programming, but eight years after its publication, the book still does not get the widespread adoption it deserves.

Setting The Stage

Special Member Functions, of course, are those member functions of a C++ object that the compiler can write for you: The default constructor, the copy and move constructors, the copy and move assignment operators and the destructor.

A Regular Type in EoP roughly corresponds to the EqualityComparable combined with the CopyConstructible C++ concept, see the book for more details.

A C++ Value Type is a type that is defined by its state, and its state alone (note that EoP has a very different definition of value type). Take an int as an example. Two int objects of value 5 will behave identical under all regular operations (simplified: all operations except for taking the object’s address). Two Shape objects, however, both having the same position, color, texture, … still may end up a square and a triangle when drawn on screen. A Shape object is defined by its behaviour as much as its state. We call such types polymorphic.

There are many shades of grey in between those two extremes; let’s leave it at that crude distinction. See Designing value classes for modern C++ – Marc Mutz @ Meeting C++ 2014 for a somewhat more thorough treatment.

In this article, we will look at two different classes, Rect and Pen, and try to write their Special Member Functions hopefully as Stepanov would have us do.

Rect and Pen

The first, Rect, is simple: it’s an integral-coordinate rectangle class that we will define completely inline in the header file. Pen, however, will be quite a bit different: It will use the Pimpl Idiom to firewall its internals from users. See Pimp My Pimpl and Pimp My Pimpl — Reloaded for more on the idiom.

class Rect {
    int x1, y1, x2, y2;
public:

};

class Pen {
    class Private; // defined out-of-line
    Private *d;
public:

};

The first task for today is to write the default constructor.

Default Construction

EoP has this to say about the default constructor:

[It] takes no arguments and leaves the object in a partially-formed state.

Ok, so what’s a “partially-formed state”? Here comes the good part:

An object is in a partially-formed state if it can be assigned-to or destroyed.

The authors go on to say that any other operation on partially-formed objects is undefined. In particular, such objects do not, in general, represent a valid value of the type.

The motivation for EoP to require default-construction in the first place is programmer convenience: T a = b; should be equivalent to T a; a = b;, and the user of the type should get to choose whether to write

T a;
if (cond)
   a = b;
else
   a = c;

or

T a = (cond) ? b : c;

Without default construction, if all the type’s author gave are user-defined constructors that establish a valid value, the programmer would have to use the ternary operator, whether or not that fits with line length limitations and personal preferences.

A default constructor for Rect

So, let’s try write something for Rect:

class Rect {
    int x1, y1, x2, y2;
public:
    Rect() = default;
};

What do you think? Would you have written the Rect default constructor this way?

I can tell you I wouldn’t have. Not until EoP opened my eyes. Remember that EoP only requires that the default constructor establish a partially-formed state, not a valid value. This should not surprise you. When in C++, do as the ints do:

int x;
Rect r;

In both cases, any use of the default-constructed object other than assignment or destruction is undefined, because the values of the objects are undefined (uninitialised).

If you feel uncomfortable with this implementation, you’re letting your inner Java programmer get the better of you. Don’t. This is C++. We embrace the undefined.

And, as Howard Hinnant writes in a reddit comment on this article, we give power to our users:

int x = {};  // x == 0
Rect r = {}; // r == {0, 0, 0, 0}

Next, let’s try Pen.

A default constructor for Pen

class Pen {
    class Private; // defined out-of-line
    Private *d;
public:
    Pen() : d(nullptr) {} // inline
    ~Pen() { delete d; }  // out-of-line
};

Should we have left Pen::d uninitialised, too?

No. Doing so would make destruction undefined.

Should we have newed a Pen::Private object into Pen::d in the default constructor?

That would be a no, too. We’re not required to establish a valid value in the default constructor, so in the spirit of “don’t pay for what you don’t use”, we only do the minimal work necessary to establish a partially-formed state.

To hammer this one home: Should an implementation of

Colour Pen::colour() const;

check for d == nullptr?

No the third. You can see at a glance in the source code whether an object is in a partially-formed state. There is no need for a runtime check, except for debugging purposes.

From the above, it follows that your default constructors should be noexcept. If your default constructors throw, they do too much. Of course, we’re still talking Value Types here, so let no man say that yours truly told you to make the default constructors of your RAII types noexcept.

Move-Construction And Move-Assignment

For Rect, moving and copying are the same thing, and the compiler is in the best position to implement them for you:

class Rect {
    int x1, y1, x2, y2;
public:
    Rect() = default;
    // compiler-generated copy/move special member functions are ok!
};

Once more, Pen is a bit more interesting:

class Pen {
    class Private; // defined out-of-line
    Private *d;
public:
    Pen() noexcept : d(nullptr) {} // inline
    Pen(Pen &&other) noexcept : d(other.d) { other.d = nullptr; } // inline
    ~Pen() { delete d; }  // out-of-line
};

We put moved-from Pen objects into the partially-formed state. In other words: moving from an object has the same effect as default-construction. Can it get any simpler?

We delegate move-assignment to the move constructor:

class Pen {
    class Private; // defined out-of-line
    Private *d;
public:
    Pen() noexcept : d(nullptr) {} // inline
    Pen(Pen &&other) noexcept : d(other.d) { other.d = nullptr; } // inline
    Pen &operator=(Pen &&other) noexcept                          // inline
      { Pen moved(std::move(other)); swap(moved): return *this; } 
    ~Pen() { delete d; }  // out-of-line

    void swap(Pen &other) noexcept
      { using std::swap; swap(d, other.d); }
};

Note how all special member functions except the destructor are inline so far, yet we didn’t break encapsulation of the Pen::Private class.

Controversy

Thanks in no small part to the ISO C++ standard, which describes moved-from objects (in [lib.types.movedfrom]) as follows:

Objects of types defined in the C++ standard library may be moved from. Move operations may be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

the simple chain of reasoning described so far has less friends than you might think. And this is why I wrote this article.

You will probably meet a lot of resistance when trying to implement your default and move constructors this way. But think about it: What would a natural “default value” of your type be?

It’s easy to fall for the next-best choice: For int, surely the default-constructed value should be zero, and we just have to put up with this partially-formed, nay: uninitialised, values because C sucks.

I disagree. If you are using the int additively, then, yes, zero is a good default value. But if you work with multiplication, then one would be the better fit.

Bottomline: for the vast majority of types, there is no natural default. If there isn’t, then having to establish a randomly-chosen one on every default-construction operation is wasteful, so don’t do it.

Instead, have the default constructor establish only a partially-formed state, and provide literals (or named factory functions for something more complex) for the different “default” values:

class Rect {
    static constexpr Rect emptyRect = {};
};

class Pen {
    static Pen none();
    static Pen solidBlackCosmetic();
};

Embracing Partially-Formed Objects

Partially-Formed Objects are nothing magical. They offer a simple description of the behaviour of C++ built-in types with respect to default construction, and of pimpl’ed objects with respect to move semantics, if implemented in the natural way.

In both cases, partially-formed objects are easily spotted in source code with local static reasoning, so demands for anything more fancy than the bare minimum as the result of moving from an object or default-constructing one are violating the C++ principle of “don’t pay for what you don’t use”. As a corollary, keep your default constructors noexcept.

In a future instalment, we will look at a smart pointer that encodes these guidelines for use as a pimpl-pointer.

The post Stepanov-Regularity and Partially-Formed Objects vs. C++ Value Types appeared first on KDAB.

A couple of years ago during a hackathon, a couple of us wrote a Qt wrapper around PDFium, the open-source PDF rendering engine which is used for viewing PDFs in Chromium.  There have been a few fixes and improvements since then.  Now we (finally) have made this module available under the LGPLv3 license.

QPdfDocument can render a PDF page to a QImage, and there is QPdfBookmarkModel which can be used for a bookmarks view. There is an example application: a widget-based PDF viewer.

If you want to try it out, here’s how to get started:

git clone git://code.qt.io/qt-labs/qtpdf
cd qtpdf
git submodule update --init --recursive
qmake
make
cd examples/pdf/pdfviewer
qmake
make
./pdfviewer /path/to/my/file.pdf

There is some work in progress to add support for PDF in QtQuick, to treat it as an ordinary image format and to add support for multi-page image formats in general, but we don’t have any particular target release date yet.

The post New QtLabs PDF module appeared first on Qt Blog.

We are delighted to announce the release of Qbs 1.7 “Technical Ecstasy”!

While Qbs 1.7.0 was actually released back in mid-December, we decided to postpone the announcement until after last week’s 1.7.1 patch release in order to get in a few more bug fixes.

What’s new?

In addition to lots of bugfixes and smaller improvements, as well as some significant performance enhancements, this release also brings a number of new features. Let’s start with the largest and most interesting:

Generators

Generators are a major new feature in Qbs 1.7 that enables deep integration with your favorite third-party development tools.

The Generators API is designed to be very generic. It provides a means for developers to create “plugins” that perform arbitrary processing on the build graph. So, far we’ve used this to create several generators which output Xcode* and Visual Studio project files. This allows you to develop your projects in your favorite IDE, while still retaining the full power and expressibility of the Qbs build engine.

We’ve also received a community contribution that outputs a Clang compilation database file. This allows Clang-based tools to scan the sources exactly like the compiler, independently of the build system. We’re excited to see what other generators the community might come up with.

To get started with generators, try the qbs generate command on your project. The generators documentation will be available in the manual in a future release.

Note that the generators features are still very experimental. We will greatly appreciate your feedback in this area.

* the Xcode generator is scheduled for release in Qbs 1.8

Other new features

• Group items can now be nested. This allows Groups to be structured more naturally, as a Group’s condition property is logically ANDed with its parent’s. It also makes Groups more useful when placed into dedicated files as the inherited QML-like syntax requires a root element.
• qrc files can be automatically generated from your project file, obviating the need to manually maintain multiple identical file lists. This functionality is part of the Qt.core module and introduces a couple of new properties which allow you to control how files in your project should be automatically added to a generated qrc file.
• There is now much more complete documentation on Rule authoring. This has been one of our biggest requests in the documentation area.
• Stricter type checking for properties in Qbs project files, which should help make certain syntax errors much clearer.
• Microsoft Visual Studio 2017 support in the C/C++ module.
• QtScxml support in the Qt modules.
• Support for building Inno Setup installers.

One last thing worth mentioning is that the Open Source C++ package manager Conan has added support for Qbs. We believe integrations like this which make it easier to integrate third-party content with your projects are a great ecosystem boon.

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 on #qt-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 most major 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.

Qbs 1.7.1 is also included in Qt Creator 4.2.1, which was released last week.

The post Qbs 1.7 released appeared first on Qt Blog.

A while ago I wanted to implement save and load for an application. The application model was a QObject derived class, with a bunch of sub (-sub) classes. As the UI was QML, everything was accessible through properties. Instead of writing a save and load mechanism for every single class, I was able to write one generic save load mechanism. This can be done using QObject introspection/reflection. So the class name, properties and member functions can be queried.

It is the time of the year when we take a look back and see who have been the Qt Champions this year.

First I would like to point out that all the people nominated are all incredible!

Let’s take a quick look at all the nominees:

• JKSH– a long time Qt developer, who shows up almost everywhere where you look. And I do mean everywhere, take any Qt online service we have and he can be found there. Maybe not the first person you run into, but always there helping people with Qt.
• kshegunov– a newer face in the Qt Community, but has already made an impact. Has contributions into Qt during his first year as a community active. You can also find him in the C++ Gurus section of the Qt Forums answering and sometimes asking hard questions.
• Ekke– with a strong background in BlackBerry development, Ekke has moved to full time to the Qt community recently. He has a running blog post series on Qt for mobile development and he made the event applications for both QtCon and Qt World Summit this year. As a long time developer he has provided the developers of Qt Quick Controls 2 with a lot of feedback and ideas.
• BenLau– another long time Qt developer. He has done a lot with Qt, and got some mentions from the developers of QML too. You can find Ben in many places, also the QtMob slack group, where Qt mobile developers gather nowadays. Take a peek at Bens github page to see a nice green wall.
• mrjj– is a familiar name to anyone on the Qt Forum. Among the top three active contributors on the Qt Forum and especially this year he has been incredibly helpful and active.
• VoidRealms– 155 Qt videos on YouTube and counting. And 155 code examples to go with those 155 videos. Also a bunch of projects and other code examples in Qt and multiple other languages too. He has been working with Qt for a long time and still releases videos at a steady pace.

As a short reminder, Qt Champions  are people who go the extra mile for the Qt community. They help out newcomers and make the community a welcoming and friendly place for everyone. The categories for Qt Champion nominations go as follows:

• Community Builder– helping the Qt community
• Ambassador– making Qt known
• Content Creator– creating and sharing original Qt content
• Maverick– significant and surprising contributions
• Rookie of the Year– best first contribution to the Qt codebase

In light of the sheer skill and persistence of all the nominees, I find it hard to do anything else than award all the nominees the title of Qt Champion 2016.

The categories for our new Qt Champions go as follows:

• Community Builder: JKSH and mrjj
• Ambassador: Ekke
• Content Creator: VoidRealms
• Maverick: Benlau
• Rookie of the Year: kshegunov

Please join me in congratulating the new Qt Champions!

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

2016 was a big year forV-Play Apps. After its initial release in August 2015, the V-Play Apps SDK has been improved tremendously. We’ve added a lot of features to the tool this year and made even more open-source example apps available to V-Play developers. To celebrate this, we’ve produced a short video to help you find out what V-Play Apps is all about!

Check it out to find out why V-Play Apps should be your first choice when it comes to cross-platform development!

What is V-Play Apps?

Build Your App with QML & JavaScript

V-Play Appsis a tool for creating cross-platform apps using QML and JavaScript. QML is a rapid development language that’s easy to learn, and perfect for making feature rich, animated UIs. JavaScript is used to control your app’s logic.

Create Truly Cross-Platform Mobile Applications

Mobile apps created with V-Play Apps have a single code base. You can use the same source code to deploy your app to Android, iOS and other platforms. And because all V-Play Apps feature responsive-design as standard, your apps will have a native look and feel on all platforms.

Develop for Free or Upgrade for Advanced Features & Support

You can develop and release your mobile app with V-Play Apps for free. For advanced support, training and features, you can sign up forV-Play Indieon a monthly or yearly basis. For an all-inclusive package and early access to new V-Play features, you can evaluateV-Play Enterprise.

See ourpricing pageorget in touchfor all the options. We’re happy to help!

How Does V-Play Apps Work?

V-Play & Qt

V-Play Appsis based on Qt, the framework behind popular applications such as Skype, VLC Player and Autodesk Maya. There are over 1 million active Qt developers in the world today, with more on the way.

Qt development with V-Play presents mobile app developers with a whole new world of possibilities. V-Play Apps comes with ready-made Qt components for sensors, advanced connectivity options, multimedia and HTML5 content, shader effects, and much more.

Emulate Different Mobile Platforms As You Develop

V-Play Apps allows you to emulate different platforms while developing on your desktop. With our platform emulation feature, you can see what your app will look like on an iPhone 4 or a Nexus tablet instantly. Visual components automatically change their style, depending on your target platform.

Get Responsive Design On All Devices

You can also switch between different resolutions during development builds to see how your app or game will appear on different devices. This makes testing much easier as you don’t need to deploy your app or game to real devices to see what it will look like on an iPhone or a Nexus tablet.

Enjoy Native Look & Feel On All Platforms

V-Play Appsrun fully native on devices without using any wrapper or hybrid methods. Our auto-adjusting UI elements can change from being a navigation drawer on Android device to being a tab on your iPhone. This means your users can enjoy a native look & feel while using your app.

Access to Camera, Sensors, File System and many more native device features also work as intended.

What Are the Benefits of V-Play Apps?

Ease of Use, Time Savings & Customer Satisfaction

The main benefits ofV-Play Appsare its ease of use and time savings. In fact, V-Play has beenranked higherthan Xamarin, PhoneGap, Unity, Corona and others as the easiest-to-use cross-platform tool with the most time-savings and most satisfied customers..

It’s thecomponent-based approachthat makes V-Play so easy to learn and implement. In some cases, mobile apps created with V-Play had 10x less code than apps created with other frameworks. These code reductions mean less bugs to fix and more time to concentrate on testing and improving your app before release.

It also means you can go from developing an app in weeks and months to making a complete app in just a few days.

And if you ever need some extra help or have a feature request, you can get in touch with our highly-rated support team. Drop us a line atsupport@v-play.netif you have any questions!

V-Play Plugins

If you want to include advertising, analytic tools or other services in your app, you can save even more time by choosing from our wide range ofV-Play Plugins. You can monetize your app with native in-app purchases and multiple ad networks with rewarded videos, interstitials or banner ads.

You can use the Google Analytics plugins to gain insights on user behaviour within your app. Or you can send push notifications or add social features to engage your users with ease. It will take you less than 10 minutes to integrate these plugins, using only 10 lines of code, which then works cross-platform.

Here’s a quick example of how you can add the OneSignal plugin to your V-Play App and send a simple push notification:

import QtQuick 2.0
import QtQuick.Controls 2.0
import VPlayPlugins 2.0

ApplicationWindow {

  OneSignal {
    appId: ""
    onNotificationReceived: {
      console.debug("Received push: ", message)
    }
  }
}

To see an example of how easy it is to add V-Play Plugins to your V-Play App, check out our quick guidehere.

Extendable Code

If you have existing native code or if you want to use a 3rd party SDK, you can extendV-Play Appswith C++, Java or Objective C code without any limits.

What Else Should I Know About V-Play Apps?

Open Source App Examples

V-Play Apps comes with a selection ofopen-source app examples. These app examples can be used as the basis for your own app and can be changed in any way you like.

For example, you can adapt a Twitter Viewer app created with V-Play, in just 700 lines of code. It connects with the Twitter REST API and includes advanced animations and native navigation on all platforms – you can use thisopen-source codefor free in your own app!

The easiest way to view these app examples is with theV-Play Sample Launcher. This standalone application offers access to all of V-Play’s app examples. You can download it for freehere!

You can also access these app examples directly from the SDK. Navigate to/Examples/V-Play>in your V-Play installation.Just open the .pro files with Qt Creator and you can run the demos on your development PC or deploy them to your mobile devices.

V-Play Apps Showcase App

You can get a quick overview of the power of V-Play Apps by downloading ourQt 5 Showcasesapp from the App Store or Google Play.

ThisQt 5 Showcases Appcontains multiple application samples developed with V-Play Apps. It shows developers and designers how V-Play Apps is used to create mobile apps with native user experience (UX) and fluid UI animations.

Download V-Play Apps for Free

Get your free V-Play Apps download now and start making your cross-platform mobile app!

Download V-Play Apps Now!

If you’re completely new to Qt and mobile development, you can take a look at ourGetting Startedguide for help!

More Posts like This

20 Free & Secure Alternatives to the Parse Push Service

The 13 Best Qt, QML & V-Play Tutorials and Resources for Beginners

21 Tips That Will Improve Your User Acquisition Strategy

7 Useful Tips That Will Improve Your App Store Optimization

The post How to Make Cross-Platform Mobile Apps with Qt – V-Play Apps appeared first on V-Play Engine.

Android Things is Google’s answer to creating an environment for IoT devices. Take a slimmed down Android build, add some sensor-specific APIs, and provide it on a number of powerful pre-integrated micro-boards and you have a ready-made platform for building a host of upcoming IoT devices. Android Things can take advantage of many existing Android […]

The post “Unboxing” the Android Things Developer Preview appeared first on KDAB.

In this article, I will take a look at one of the fundamental concepts introduced in Alex Stepanov and Paul McJones’ seminal book “Elements of Programming” (EoP for short) — that of a (Semi-)Regular Type and Partially-Formed State. Using these, I shall try to derive rules for C++ implementations of what are commonly called “value […]

The post Stepanov-Regularity and Partially-Formed Objects vs. C++ Value Types appeared first on KDAB.

The last post from my colleague Marc Mutz about deprecating Q_FOREACH caused quite an uproar amongst the Qt developers who follow this blog. I personally feel that this was caused fundamentally by a perceived threat: there is a cost associated to porting away a codebase from a well-known construct (Q_FOREACH) to a new and yet-undiscovered […]

The post Un-deprecate your Qt project appeared first on KDAB.

V-Play 2.10.0 is here and it includes all the new features of Qt 5.8, as well as Qt Creator 4.2.

It adds anew Showcase Appwhich combines all V-Play app demos in one application. It includes some of the most common app components used today and you can access it’s full source code from your V-Play installation. You can read more about it here!

The update also includes a number of newV-Play Multiplayerfeatures to improve matchmaking. Check out the detailshereand find out how you can now add and remove players during live games.

As well as that, V-Play 2.10.0 improves support for language localization within mobile apps and games. You can now develop your apps and games using your default language and V-Play will automatically find the best translations for your text!

V-Play developers can find details on how to successfully update to Qt 5.8here.

New V-Play developers cansign-up nowand get the tool for free!

Update V-Play Now!

Qt 5.8 and Qt Creator 4.2 Support

V-Play 2.10 lets you use features from the newly released Qt 5.8 and Qt Creator 4.2. This update includes a wide-ranging selection of new features, including Qt Quick Controls 2.1. Check out this video to learn more about the update:

Along with these new Qt features, V-Play 2.10.0 gives you advanced language support and new in-app purchase features.

Internationalization Support

V-Play apps and games now make it easier to support multiple languages. Create your app using default texts and easily support different countries and languages by enabling translations.

The correct translation is automatically chosen based on the detected system language of the device. To manually switch the language at runtime, use the newGameWindow::settings.languageproperty. This feature can be added to your app or game in minutes with this block of code:

GameWindow {   Scene {     Column {// create a localizable text with qsTr() and// make it dynamically change by binding to translation.language       Text {         anchors.horizontalCenter: parent.horizontalCenter         text: qsTr("Hello World") + translation.language       }// toggle language between german and english on button press       ButtonVPlay {         readonly property bool isEnglish: settings.language ==="en_EN"         text: "Switch to "+ (isEnglish ? "German" : "English")         onClicked: settings.language = isEnglish ? "de_DE" : "en_EN"       }     }   } }

You can readHow to Make a Multi Language App or Game with V-Playfor more information!

SyncedStore

You can now use theSyncedStorecomponent together with theSoomla Pluginto synchronize your in-app purchases across devices.

This new feature allows users to purchase goods in your game or app as before, but additionally uses the V-Play Game NetworkWebStorageto synchronize the balance of your virtual goods and currencies between the user’s devices.

How to Update to Qt 5.8

Make your switch to the latest versions of V-Play and Qt as smooth as possible with these guidelines:

• After updating, open theMaintenanceToolin your V-Play SDK installation folder and remove Qt 5.7 from your installed components. Since V-Play is not compatible with Qt 5.7 anymore, it is best to remove these kits.
• Qt Creator should automatically detect the kits for Qt 5.8, which you can use to build your V-Play projects.
• To enable one of the new Qt 5.8 kits, click “Projects” on the left side of Qt Creator and enable your desired kit in the tree below “Build and Run”

• Qt 5.8 for Android requires the latest Android NDK. You can download the NDKhere.

Showcase Component App Update

The updatedComponent Showcase Demo Appcombines the most important V-Play Apps features in a single app with native user experience (UX) and fluid UI animations.

iOS                                            Android

You can use the showcase app to see how V-Play Apps handles:

• Theming and native platform styles
• Native dialogs, camera/image picker and share features
• Embedded maps and GPS positioning
• Embedded video, audio and WebView
• Shader effects and fluid animations
• Native styled controls and Qt Quick Controls
• Local storage, app navigation, lists and sections

Download the Showcase Component App

The V-Play Showcase Component app is one of the easiest ways for you to see the power of V-Play. Best of all, you can access the full source code of the app from your V-Play installation. You can use this source code in any way you like to build mobile apps or games.

iOS

Android

Sign-upfor V-Play now and check out the source code for free!

You can launch theShowcase Component Appfrom the V-Play Sample Launcher, Qt Creator or from yourinstallation directory.

You can also download it free foriOS from the App Storeor forAndroid from the Google Play Store.

Improvements

V-Play 2.10.0 includes more improvements to V-Play Game Engine, V-Play Apps and V-Play Plugins than any other recent update.

V-Play Apps

V-Play 2.10.0 includes lots of new features and improvements for mobile app development.

Native Sliders

You can now build even better UIs with our native looking sliders for iOS and Android. Use theAppSliderorAppRangeSlidercontrols to select values and ranges with native appearance for iOS and Android.

AppFlickable Component

The update includes scrolling and display improvements to theAppFlickablecomponent.

It now uses a defaultmaximumFlickVelocityof dp(3000) which matches theAppListViewflick velocity. It also supports scrolling to the top when the statusbar is clicked on iOS.

Navigation Styling

V-Play 2.10.0 includes a number of new styling options for the NavigationBar component. You can now show or hide the NavigationBar drop shadow with the newNavigationStack::navigationBarShadowproperty.

You can also show or hide a drop shadow below the NavigationBar on Android with theNavigationStack::navigationBarShadowproperty. The shadow height is customizable with theTheme.navigationBar.shadowHeightsetting.

As well as that, thePageControlcomponent now allows you to jump to a specific page by directly clicking the indicator.

More Changes

For a full list of improvements to V-Play Apps in this update, please check out ourchange log!

V-Play Game Engine

Connect with Facebook

V-Play now lets you connect your matchmaking service and leaderboards with Facebook, giving users even more social features.

The VPlayMultiplayerView for matchmaking and VPlayGameNetworkView for leaderboards now shows a button that allows players to connect to Facebook if a VPlayGameNetwork::facebookItem is configured.

If players connect with Facebook and give access to their friends list, they can directly compare scores with their Facebook friends. They can also challenge them to multiplayer matches without the hassle of manually searching for their friends in the game. The player profile, which includes scores, achievements and friends, is synchronized if a player uses the same account on multiple devices.

V-Play Multiplayer

You can enjoy a number of improvements to theV-Play Multiplayerfeature when you update to V-Play 2.10.0. These updates make it easier for players to begin games or join in existing games.

For example, you can now use the VPlayMultiplayer::invitePlayers() or VPlayMultiplayer::uninvitePlayer() methods to add or remove players while the game is already open.

You can activate or deactivate player slots with theMultiplayerUser::enabledproperty orVPlayMultiplayer::enablePlayer() andVPlayMultiplayer::disablePlayer() methods. This allows you to make multiplayer game for 2, 3, or more players.

V-Play 2.10.0 also lets you customize the random join feature with the new properties VPlayMultiplayer::customFilterProperties and VPlayMultiplayer::filterSqlQuery so players only join rooms that match their set filter.

These advanced matchmaking options should boost user engagement and retention as these new features give players more control over who they interact with in your game.

Learn more about V-Play Multiplayerhere!

V-Play Plugins

TheAdMob,ChartboostandFlurryplugin have all been updated by this release. All 3 plugins now use the latest platform SDK’s for iOS and Android. You can learn more about this by visiting theplugin documentationpage.

See the V-Playchange logfor a full list of the improvements this release brings to V-Play!

Fixes

V-Play 2.10.0 includes fixes for V-Play Apps, V-Play Game Engine and V-Play Plugins. The most important fixes involve V-Play Apps and resolve the following issues:

• Fixes a compatibility issue ofAppTabBarwith Qt 5.8 that broke the rendering of the tab buttons.
• Solves issue ofAlphaVideonot showing on some Android devices and correctly scales the video when the item size changes.
• HiddenDialogandInputDialoginstances no longer consume the Android back-button after they are closed.

You can see all the fixes this update brings by checking out our change loghere!

How to Update V-Play

Test out these new features by following these steps

Step 1

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

If you haven’t installed V-Play yet, you can do so now with the latest installer fromhere.

Step 2

The V-Play Sample Launcher allows you to quickly test and run all the open-source examples and demo apps & games that come with the V-Play SDK, from a single desktop application.

Afterinstalling V-Play, you can start the V-Play Sample Launcher from the application shortcut in your V-Play SDK directory.

Now you can explore all of the new features included in V-Play 2.10.0!

For a complete list of the changes to V-Play with this update, please check out ourchange log!

NOTE:Please see theparagraph aboveon how to successfully update to Qt 5.8 for V-Play. Some additional steps are required!

More Posts like This

20 Free & Secure Alternatives to the Parse Push Service

The 13 Best Qt, QML & V-Play Tutorials and Resources for Beginners

21 Tips That Will Improve Your User Acquisition Strategy

7 Useful Tips That Will Improve Your App Store Optimization

The post Release 2.10.0: New App Showcase, Multiplayer & Multi-Language Improvements, Qt 5.8 appeared first on V-Play Engine.

I am boarding my flight to Brussels to attend FOSDEM.

The Desktops DevRoom will be a blast again this year. While I have been in charge of it for 6? years already, the last two (since my twins) were born I had organized remotely and local duties were carried on by the Desktops DevRoom team (thank you Christophe Fergeau, Philippe Caseiro and others!).

I am anxious at meeting old friends again. I will be at the beer event today.
Video streaming will be available and thanks to the Video Team. If you want to help, please contact us in the desktops-devroom@lists.fosdem.org mailing list, or directly at the devroom.

Also, this year will be the first for me using the job corner to recruit: my company (everis) is recruiting globally for many open positions. Drop us a mail at fosdem@everis.com with your CV, desired position and location (we have direct presence in 13 countries and indirect in 40 countries) and I will make sure it reaches the right inbox.

So, 2016 has been a great year to me. Interesting in many aspects, but most has turned out to be for the better. I’ve gotten to know a bunch of awesome new people, I spoken about open source, Qt and Linux in Europe and USA, I’ve helped hosting an open source conference in Gothenburg, I’ve learned so much more professionally and as a person, and I’ve really enjoyed myself the whole time.

2016 was the year that…

• … myself and Jürgen where Qt Champions for our work with the qmlbook. It feels really great getting recognition for this work. I really want to take QML Book further – during 2016 both myself and Jürgen have been too busy to do a good job improving and extending the text.
• … I had to opportunity to visit the Americas (Oregon and California) for the first time in my life. Felt really nice having been on another continent. Now it is only Africa and Australia left on the list :-)

• … I picked up running and has run every week throughout the year, averaging almost 10km per week. This is the first year since we built out house and had kids (so 11 or 12 years) that I’ve maintained a training regime over a full year.
• …foss-gbg went from a small user group of 15-30 people meeting every month to something much larger. On May 26 the first foss-north took place. This is something some friends of mine and myself have discussed for years and when we finally dared to try it was a great success. We filled the venue with 110 guests and ten speakers and had a great day in the sunshine. In the events after foss-north, the local group, foss-gbg has attracted 40-60 people per meeting, so double the crowd.

• …Pelagicore, the start-up I joined in 2010 when we were only 6 employees, was acquired by Luxoft. We had grown to 50+ employees in the mean time and put Qt, Linux and open source on the automotive map. It has been a great journey and I feel that we being a part of something bigger lets us reach even further, so I’m really excited about this.

2017 will be the year that…

• … I make more time for writing – on qmlbook, this blog and more.
• … I improve my running and increase my average distance per run as well as distance per week.
• …foss-north will take place again. This time with double the audience and dual tracks for parts of the day. I will share more information as it develops. This time, the date to aim for is April 26. In the mean time, foss-gbg will have fewer, but larger, meetings.
• … Qt, Linux and open source becomes the natural choice in automotive. I will do my best to help this turn out true!

Even as 2016 has been really good, I hope that 2017 will be even greater. I’m really looking forward to learning!

We know that many Qt users want controls styled with a native look-and-feel. But offering that on platforms with no public styling API, is hard. A classic approach is to take snapshots of the native controls, tweak them, and use them as foreground or background in our own controls. Which is somewhat OK for static appearances. But when animations and transitions are involved, static pixmaps will only take you half the way. And since an OS can change style from one update to the next, taking snapshots runtime is risky. Using pre-grabbed snapshots is also something we don’t do because of legal considerations.

Since December last year, the controls team has been researching a bit small scale on a new project to offer controls with true native look-and-feel. The aim is to do the alternative to the above standing, and explore how feasible it would be to wrap actual native controls into a cross platform Qt API. Such ideas is nothing new of course, and have been discussed many times, at least internally. One of the problems is that different platforms can vary quite much API-wise, especially for more complex controls like tab-, and split views, with some having a rich API, while others are more limited. And unifying that into a common useable Qt API is a challenge.

Currently we have prototyped a set of controls, together with a plugin-based framework and a few backends for testing (uikit, appkit, android). The API is small and strict so that it can be realized on all supported (and future) platforms. As such, the controls become rather black box, since we cannot make assumptions on how they are implemented by the backends. Still, there will be times when you need to detail how your application should work on a specific platform. For that reason we plan to open up, and factor out, the various backends into separate libraries that can be accessed directly. Those libraries will wrap parts of the native APIs more closely, and offer building blocks specific to the platform, or controls with a broader set of functions and properties. They will be more open than the common controls, giving access to the native controls they wrap, to let you dig into to native development whenever you need to fill gaps that falls outside our own scope. In the end, it should be easy and straightforward to mix cross-platform controls, platform-specific controls, and native code in your application.

I’ve mentioned “APIs” a couple of times. This of course includes QML. But we also plan to offer direct access to the underlying C++ libraries, making it easy to extend the API, and write application using C++ only. That way you can choose whether you want to use QML, C++, or a combination.

Here is a snippet showing how things look so far. The app mixes a couple of cross-platform controls (common controls) together with a control directly from the AppKit backend.

import QtQml 2.0
import Qt.CommonControls 1.0 as Common
import Qt.AppKitControls 1.0 as AppKit

Window {
    id: window
    visible: true

    Common.Button {
        id: button
        x: 20
        y: 20
        text: "Click me"
        onClicked: text ="You clicked me!"
    }

    Common.TextField {
        id: textField
        placeholderText: "TextField"
        x: 20
        y: button.bottom + 8
    }

    AppKit.SearchField {
        placeholderText: "Search"
        x: 20
        y: textField.bottom + 8
    }
}

The next snippet shows the same app, but this time in C++

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);
    QCommonWindow window;

    QCommonButton commonButton(QStringLiteral("Click me"), &window);
    commonButton.move(20, 20);
    QObject::connect(&commonButton, &QCommonButton::clicked, [&commonButton](){
        commonButton.setText(QStringLiteral("Clicked!"));
    });

    QCommonTextField textField(&window);
    textField.setPlaceholderText(QStringLiteral("TextField"));
    textField.move(20, commonButton.bottom() + 8);

#if defined(Q_OS_MACOS)
    QAppKitSearchField searchField;
    searchField.setParent(&window);
    searchField.move(20, textField.bottom() + 8);
    NSSearchField *nsSearchField = searchField.nsSearchFieldHandle();
    nsSearchField.placeholderString = @"Search...";
#endif

    window.showFullScreen();
    return app.exec();
}

As mentioned, we plan to keep the API rather strict. The common controls will only contain the basics, with few, or no possibilities for tweaking the style, catching internal events, or overriding default behaviour. You basically get native controls with native look, feel and behaviour. If you, on the other hand, need custom styling, or your own custom controls, Qt offer solutions like QtQuickControls2, or Widgets, for that already. Our current thinking is that this module will be something for Qt6.

The post Native look and feel appeared first on Qt Blog.

Have you ever had the need to visualize data graphically and add some ‘wow’-effect to it? I’m currently helping out with the development of a demo application, where we have some charts to visualize data received from sensors. Naturally, the designer wants the charts to be visually appealing.

At the beginning we had basic graphs to show the data, one of them being temperature. We used LineSeries QML type from Qt Charts with dynamic for this.

Temperature represented as LineSeries.

Now to make the graph more polished we decided to hide the labels and the grids drawn to the chart and make the background transparent. This way we had only the series drawn to the area reserved for the graph. To achieve this we modified our ChartView with two axis and a series to the following:

ChartView {
    id: chartView
    backgroundColor: "transparent"
    legend.visible: false

    ValueAxis {
        id: valueAxisX
        min: 0
        max: maxNumOfTempReadings + 1
        visible: false
    }

    ValueAxis {
        id: valueAxisY
        min: minimum
        max: maximum
        visible: false
    }

    LineSeries {
        id: avgTempSeries
        axisX: valueAxisX
        axisY: valueAxisY
        color: chartColor
    }
}

But having just the series was no fun. With the main background of the application and the temperature values we had a chart that looked like in the following picture.

Temperature chart without effects.

As the design specification had some glow on elements in the UI, we decided to give a try to some graphical effects QML has to offer, more precisely the Glow effect. We added the Glow element to the same level with the ChartView (Glow and ChartView elements are siblings).

Glow {
    anchors.fill: chartView
    radius: 18
    samples: 37
    color: "#15bdff"
    source: chartView
}

With the above code it was very easy to add some glow to the chart series. The same chart as shown in the beginning with the mentioned changes and some additional elements ended up looking like in the following picture.

Temperature graph with a glowing series.

Want to spice up your charts? Go and give it a try, it’s really easy.

The post Glowing Qt Charts appeared first on Qt Blog.

The Qt World Summit 2016 sessions recordings are now available on-demand! Whether you had the chance to see us at #QtWS16 live last year or missed us, you can watch experts covering everything from the Future of technology, HMI strategy planning and project management to deep dives into user experience design for software engineers and much more.

There was a lot happening on-stage by a myriad of speakers including Qt company experts, industry leaders, and our more than capable partners–and you can relive those moments.

Recommended categories:

• Keynotes – watch how we kick-started #QtWS16!
• Deep tech and UI/UX – get the tips & tricks from the Qt experts
• Built with Qt – check out the buzz around Qt in the industry

So pull up a chair, grab a beverage and enjoy the show!

And in case you missed it, see what #QtWS16 attendees from Ubuntu, Tableau, and LG had taken away about Qt:

To stay tuned for Qt World Summit 2017 updates, subscribe for the newsletter at http://www.qtworldsummit.com.

The post Missed the Qt World Summit 2016 sessions? appeared first on Qt Blog.

Missed the Qt World Summit 2016 sessions? Watch the show right now at https://www.qt.io/qtws-videos/

Whether you had the chance to see us at #QtWS16 live last year or missed us, you can watch experts covering everything from the future of technology, HMI strategy planning and project management to deep dives into user experience design for software engineers and much more.

There was a lot happening on-stage by a myriad of speakers including Qt company experts, industry leaders, and our more than capable partners–and you can relive those moments.

Recommended categories:

• Keynotes – watch how we kick-started #QtWS16!
• Deep tech and UI/UX – get the tips & tricks from the Qt experts
• Built with Qt – check out the buzz around Qt in the industry

See what some of the attendees thought about the show:

So pull up a chair, grab a beverage and enjoy the show!

• LG https://youtu.be/EDwQtKH6tk8
• Tableau https://youtu.be/YX7jCsXZqhs
• Ubuntu https://youtu.be/zBIT4lWMVDo

The post Qt World Summit 2016 session videos are now available appeared first on Qt Blog.

• brand new website, with searchable documentation
• user manual: in-app (with context help) and on-line
• user-defined functions
• complex numbers
• unit support, including conversions
• implicit multiplication
• bitfield widget, for people who deal with binary math
• virtual keypad is back
• double-click to insert into editor is back
• more color schemes, including Solarized alternatives
• currency symbols are ignored, you can now safely paste them into the editor
• official 32- and 64-bit Linux packages available
• donations finally possible

A year has gone by since I started work with Canonical. As it turns out, I must be on my way. Where to? Not real sure at this moment, there seems plenty of companies using Qt & QML these days. \0/