Learn what Felgo offers to help your business succeed. Start your free evaluation today! Felgo for Your Business

Contents

Felgo Updates (Older Releases)

v 2.18.2 (2018-11-07)

Highlights Blog Post: Release 2.18.2: MVC, MVVM, Flux with QML

Felgo 2.18.2 adds the latest Qt Creator 4.7, as well as many improvements and fixes. A new comprehensive guide helps you to structure your code, and separate logic from UI (MVC, MVVM, Flux).

Felgo 2.18.2 comes as a free update for all Felgo developers.

Highlights

  • Felgo now ships with Qt Creator version 4.7, giving you the latest stability improvements, fixes and new features.

    Update Note: For using the Qt Quick Compiler, which is the default for building in Release Mode with Qt Creator 4.7, it is required to list each qml file with an own entry in your resources.qrc. Otherwise, the compiler does not find the QML source files.

    To deactivate the QML compiler, you can use the CONFIG -= qtquickcompiler setting in your *.pro configuration. This only protects the QML resources and bundles them as assets within your binary. You can also skip a specific .qrc configuration with e.g. QTQUICK_COMPILER_SKIPPED_RESOURCES += bundle_only.qrc.

  • This Felgo update adds a new comprehensive developer guide: Separation of Model, View and Logic Code in your Qt App using QML

    The guide offers a best-practice solution how to separate model, view and logic components in your Felgo apps:

    A clean component architecture and data-flow helps to keep create readable code, avoids bugs and makes maintenance or refactoring easy.

    You can find the full example of the guide on GitHub:

    It is available as a project wizard template in Qt Creator as well:

    All Felgo Apps Examples and Demos now also use this best-practice solution.

New Features

  • Adds method FirebaseAuth::loginUserWithToken() to login a user with a custom authentication token.
  • You can now configure the Android status bar opacity with the Theme.colors.statusBarOpacity property.
  • Use AppButton::rippleEffect to control whether to show or hide a ripple effect for the button.

    This example hides the effect for a single button:

     import Felgo 3.0

 App {

   AppButton {
     text: "No Ripple Effect"
     onClicked: console.log("clicked")
     rippleEffect: false
   }

 }

    You can also use Theme.appButton.rippleEffect to change your app's default setting:

     import Felgo 3.0

 App {

   onInitTheme: {
     Theme.appButton.rippleEffect = false
   }

   AppButton {
     text: "No Ripple Effect"
     onClicked: console.log("clicked")
   }

 }

Improvements

  • Adds new property FirebaseConfig::name.

    You can use more than one FirebaseConfig instance by assigning a different unique name to each instance. These names are used for persistence and should be the same between app starts.

  • AppActivityIndicator now uses a RotationAnimator instead of a RotationAnimation to rotate the activity or loading indicator also if the UI thread is blocked. This allows a better user experience and more fluid UIs.

Fixes

  • Fixes a build error when using AdMob Plugin on Android using newer Android build system versions.
  • Fixes potential crashes when using callback functions with FirebaseDatabase.

v 2.18.1 (2018-09-13)

Highlights Blog Post: Release 2.18.1: JavaScript Promises for REST Services, Tinder Swipe Material Cards, QML QSortFilterProxyModel, QML YouTube Player

Felgo 2.18.1 introduces new components for embedding YouTube videos, for creating material cards and Tinder-like swipe cards. It also simplifies connecting to REST services, with the new HttpRequest component. Felgo 2.18.1 also adds several other fixes and improvements.

Felgo 2.18.1 comes as a free update for all Felgo developers.

Highlights

  • With the YouTubeWebPlayer component, you can now directly embed YouTube videos in your app with a simple QML API.

    The component uses a WebView internally and is based on the YouTube Iframe-Player API. To show how you can use the player in your app, you can have a look at the YouTube Video Player App. It uses the YouTube Data API to browse playlists and videos of a configured channel.

    This is how you can use the player in QML:

     import Felgo 3.0

 App {
   NavigationStack {
     Page {
       title: "YouTube Player"

       YouTubeWebPlayer {
         videoId: "KQgqTYCfJjM"
         autoplay: true
       }

     }
   }
 }
  • New HttpRequest component for REST API connection, based on DuperAgent. This also includes Promises and image scaling/cropping features. You can find details and examples in the New Features section below and in the documentation.
  • New AppCard component to create material cards. You can also use Tinder-like swipe gesture with cards. With additional AppPaper and AppCardSwipeArea component, you can create fully custom card-like UI elements that can be swiped in a Tinder-like fashion.

New Features

  • The Page type now features two more signals appeared() and disappeared(). These signals fire when the page becomes active or inactive on a NavigationStack. They are convenience signals to avoid manual checks of Page::isCurrentStackPage. 
     import Felgo 3.0

 App {
   NavigationStack {
     Page {
       title: "Page"

       // this code and manual checks of isCurrentStackPage are no longer required
       onIsCurrentStackPageChanged: {
         if(isCurrentStackPage)
           console.log("Page appeared")
         else
           console.log("Page disappeared")
       }

       // instead, you can use the new signals
       onAppeared: console.log("Page appeared")
       onDisappeared: console.log("Page disappeared")
     }
   }
 }

    This example shows how all the Page lifecycle events trigger when working with NavigationStack:

    • The user pushes a page to the stack. It thus becomes the active stack page and the Page::appeared signal fires.
    • After completion of the push operation, which caused the page to appear, the Page::pushed signal triggers.
    • The user now pushes another page to the stack. The Page::disappeared signal fires for the previously pushed page, as it is no longer visible on the stack.
    • By navigating back from the second to the first page, it becomes active again and the Page::appeared signal fires.
    • If the user now fully removes the page by again popping from the stack, the Page::disappeared signal fires.
    • After completion of the pop operation, which removed the page, the Page::popped signal triggers.

    Use this snippet to test the signals yourself:

     import Felgo 3.0
 import QtQuick 2.0

 App {
   // navigation stack for pages
   NavigationStack {
     initialPage: pageComponent
   }

   // page component
   Component {
     id: pageComponent

     Page {
       id: page
       title: "Page 1"

       // allow to push and pop pages dynamically
       Column {
         anchors.centerIn: parent

         // push additional page
         AppButton {
           text: "Push"
           onClicked: page.navigationStack.push(pageComponent, { title: "Page "+(navigationStack.depth + 1) })
         }

         // pop current page
         AppButton {
           text: "Pop"
           onClicked: page.navigationStack.pop()
         }
       }

       // handle lifecycle signals
       onAppeared: console.log(title+" appeared")
       onDisappeared: console.log(title+ " disappared")
       onPushed: console.log(title+ " pushed")
       onPopped: console.log(title+ " popped")
     }
   }
 }
  • You can now use the HttpRequest type as an alternative to the default XmlHttpRequest. It integrates DuperAgent, a QML clone of the fantastic SuperAgent library from VisionMedia.

    It is available as a singleton item for all components that use import Felgo 3.0:

     import Felgo 3.0
 import QtQuick 2.0

 App {
   Component.onCompleted: {
     HttpRequest
       .get("http://httpbin.org/get")
       .timeout(5000)
       .then(function(res) {
         console.log(res.status);
         console.log(JSON.stringify(res.header, null, 4));
         console.log(JSON.stringify(res.body, null, 4));
       })
       .catch(function(err) {
         console.log(err.message)
         console.log(err.response)
       });
   }
 }

    Similar to HttpRequest, which matches the DuperAgent Request type, other DuperAgent features are also available in Felgo with the Http prefix:

    The HttpRequest type also supports response caching of your requests out-of-the-box. To change cache behavior, you can use the HttRequest::config() method. It is also possible to change cache settings for individual requests:

     import Felgo 3.0
 import QtQuick 2.0

 App {
   Component.onCompleted: {
     HttpRequest
       .get("http://httpbin.org/get")
       .cacheSave(true) // cache the result of this request, regardless of global cache setting
       .cacheLoad(HttpCacheControl.PreferNetwork) // use network if possible, otherwise load from cache
       .then(function(res) {
         console.log(JSON.stringify(res.body))
       })
       .catch(function(err) {
         console.log(err.message)
       });
   }
 }
  • The DuperAgent package, which brings the HttpRequest type, also contains an implementation of the Promises/A+ specification and offers an API similar to the Promises API in ES2017. The Promise type works independently of DuperAgents's http features and does not require the Http prefix: 
     import Felgo 3.0
 import QtQuick 2.0

 App {
   Component.onCompleted: {
     var p1 = Promise.resolve(3);
     var p2 = 1337;
     var p3 = HttpRequest
             .get("http://httpbin.org/get")
             .then(function(resp) {
                 return resp.body;
             });

     var p4 = Promise.all([p1, p2, p3]);

     p4.then(function(values) {
         console.log(values[0]); // 3
         console.log(values[1]); // 1337
         console.log(values[2]); // resp.body
     });
   }
 }

    Promises are a convenient and flexible way to handle asynchronous aspects of your application.

  • You can now use SortFilterProxyModel to conveniently apply filter and sorting settings to your QML ListModel items:

    The following example shows the configured entries of the ListModel in a ListPage, and allows to sort the list using the name property:

     import Felgo 3.0
 import QtQuick 2.0

 App {
   // data model
   ListModel {
     id: fruitModel

     ListElement {
       name: "Banana"
       cost: 1.95
     }
     ListElement {
       name: "Apple"
       cost: 2.45
     }
     ListElement {
       name: "Orange"
       cost: 3.25
     }
   }

   // sorted model for list view
   SortFilterProxyModel {
     id: filteredTodoModel
     sourceModel: fruitModel

     // configure sorters
     sorters: [
       StringSorter {
         id: nameSorter
         roleName: "name"
       }]
   }

   // list page
   NavigationStack {
     ListPage {
       id: listPage
       title: "SortFilterProxyModel"
       model: filteredTodoModel
       delegate: SimpleRow {
         text: name
         detailText: "cost: "+cost
         style.showDisclosure: false
       }

       // add checkbox to activate sorter as list header
       listView.header: AppCheckBox {
         text: "Sort by name"
         checked: nameSorter.enabled
         updateChecked: false
         onClicked: nameSorter.enabled = !nameSorter.enabled
         anchors.horizontalCenter: parent.horizontalCenter
         height: dp(48)
       }
     } // ListPage
   } // NavigationStack
 } // App

    Please see the documentation of SortFilterProxyModel for more details and relevant types.

Improvements

  • Automatically remove focus from SearchBar text field if it gets invisible.

Fixes

  • Fixes a crash in the Felgo Live Client when using WikitudeArView.
  • When a device goes online, the App::isOnline property now becomes true only after a short delay. This is required, as otherwise the network adapter might not be ready yet, which can cause immediate network requests to fail.

v 2.18.0 (2018-08-08)

Highlights Blog Post: Release 2.18.0: Update to Qt 5.11.1 with QML Compiler and Massive Performance Improvements

Felgo 2.18.0 updates to Qt 5.11.1 and adds several improvements and fixes.

Felgo 2.18.0 comes as a free update for all Felgo developers.

Highlights

  • Update to Qt 5.11.1 with numerous big improvements, such as:
    • Major changes to QML compiler pipeline and QML engine, for improved performance on all platforms.
    • Qt Quick Compiler now also available in the free version, with CONFIG += qtquickcompiler
    • Improved performance and reduced GPU usage for Qt 3D.
    • New features for Qt Location and Maps, like turn-by-turn navigation.
    • Many improvements and fixes to core modules.

Improvements

  • WikitudeArView now properly rotates the camera image to device rotation on iOS.
  • WikitudeArView now supports live reloading of the HTML/JavaScript files with the Felgo Live Client.

Fixes

v 2.17.1 (2018-07-17)

Highlights Blog Post: Release 2.17.1: Use 3D with Live Reloading and Test Plugin Code Examples from Browser

Felgo 2.17.1 adds several improvements and fixes for Felgo components. It also includes a new app example, how to create custom listview delegates.

Felgo 2.17.1 comes as a free update for all Felgo developers.

New Features

  • New examples on how to work with list views. The examples cover how to make custom list item delegates (left) and make collapsible sub-sections within list items (right):

  • The plugin documentation now also includes code examples that you can test on your mobile phone directly from the browser, using the Felgo Web Editor.

    Here is an example how to display an ad banner with the AdMob plugin:

     import Felgo 3.0

 App {
   NavigationStack {
     Page {
       title: "AdMob Banner"

       AdMobBanner {
         adUnitId: "ca-app-pub-3940256099942544/6300978111" // banner test ad by AdMob
         banner: AdMobBanner.Smart
       }
     }
   }
 }
  • App and GameWindow provide new properties to make the native keyboard handling on Android and iOS easier. You can use keyboardVisible and keyboardHeight to adapt your app layout when the keyboard is shown, like positioning controls above the keyboard.

    The following example displays a floating action button above the keyboard, that also adapts to size changes of the keyboard:

     import Felgo 3.0
 import QtQuick 2.7

 App {
   id: app

   // We unset the focus from the AppTextField after the keyboard was dismissed from the screen
   onKeyboardVisibleChanged: if(!keyboardVisible) textField.focus = false

   NavigationStack {

     Page {
       id: page
       title: qsTr("Keyboard Height")

       AppTextField {
         id: textField
         width: parent.width
         font.pixelSize: sp(25)
       }

       FloatingActionButton {
         // Add the keyboard height as bottom margin, so the button floats above the keyboard
         anchors.bottomMargin: app.keyboardHeight + dp(15)
         // We only show the button if the AppTextField has focus and the keyboard is expanded
         visible: textField.focus && app.keyboardHeight != 0
         icon: IconType.check
         backgroundColor: Theme.tintColor
         iconColor: "white"
         onClicked: textField.focus = false
       }
     }
   }
 }

Improvements

  • FileUtils::readFile() now supports reading files with any file ending, not limited to .txt or .json anymore. This allows working with shaders in the Felgo Live Client without any custom C++ code from QML.
  • Soomla In-Ap-Purchase Plugin: Store::insufficientFundsError now returns the itemId as parameter that triggered the signal.
  • AppTextField can now set the text padding with new bottomPadding, leftPadding, rightPadding, topPadding properties, inherited from the internal TextField.
  • AppButton and SwipeButton support the textFormat property to set rich text as button text label.
  • VisibilityRefreshHandler adds the canRefresh property that allows to hide the control if there is no more additional data to show.
  • Retrieve all the mobile device's contact list phone numbers on Android and iOS with the new NativeUtils::contacts property.

    The new phoneNumber property now works with Android run-time permissions.

    Note: The methods getContacts() and getPhoneNumber() are deprecated as of Felgo 2.17.1. Use the new properties instead.

  • The new property cursorInView for AppTextEdit can be used to ensure that the text cursor stays visible on the screen. For example, when adding new lines at the bottom of the screen. In that case, it moves the surrounding flick-able element in the opposite direction and therefore avoids the cursor leaving the screen.

Fixes

v 2.17.0 (2018-06-12)

Highlights Blog Post: Release 2.17.0: Firebase Storage, Downloadable Resources at Runtime and Native File Access on All Platforms

Felgo 2.17.0 adds two new demos that show how to integrate C++ code with QML and add the new DownloadableResource and FileUtils items.

Felgo 2.17.0 comes as a free update for all Felgo developers.

Highlights

  • New Firebase Cloud Storage item to upload local files to the cloud:

    With the new FirebaseStorage item, you can upload files to the Firebase Cloud Storage. It uploads local files to the cloud file system and provides a public download URL.

    You can upload files like the following:

  • Download additional assets on demand at runtime with the new DownloadableResource item.
  • Have a look at two brand-new app demos that show how to integrate C++ with QML:
    • The first example shows the different forms of C++ and QML integration: signals, slots and properties. This example is the tutorial result from How to Expose a Qt C++ Class with Signals and Slots to QML.
    • The second example shows how to combine a C++ backend that provides the model data for a frontend created in QML. The data is displayed with QML with Qt Charts for both 2D and 3D charts.

New Features

  • The FileUtils item offers features for dealing with files from QML (open, copy, delete, etc).
  • You can now set a timeout for your Felgo Multiplayer games using the new property FelgoMultiplayer::socketTimeoutMs. This is useful to prevent clients with slow connections from slowing down the entire game.
  • Create feature-rich Augmented Reality (AR) apps & games with our new Wikitude Plugin.
  • Navigation drawer entries add setting the color of the text, icon and background in default, pressed and active state. To do so, the SimpleRow::style offers the additional selectedTextColor and activeBackgroundColor properties.

    In addition, the text and icon of tabs for TabControl or AppTabButton may now use a different color while being pressed. To take advantage of this feature in your app's navigation drawer entries and tabs, the Theme provides the following new settings:

     import Felgo 3.0
 import QtQuick 2.0

 App {
   onInitTheme: {
     Theme.colors.tintColor = "red"

     // drawer + item bg
     Theme.navigationAppDrawer.backgroundColor = "lightgrey"
     Theme.navigationAppDrawer.itemBackgroundColor = Theme.tintColor
     Theme.navigationAppDrawer.itemSelectedBackgroundColor = "orange"
     Theme.navigationAppDrawer.itemActiveBackgroundColor = "white"

     // item text
     Theme.navigationAppDrawer.textColor = "white"
     Theme.navigationAppDrawer.selectedTextColor = "black"
     Theme.navigationAppDrawer.activeTextColor = Theme.tintColor

     // tab text
     Theme.tabBar.titleColor = Theme.tintColor
     Theme.tabBar.titlePressedColor = "orange"
   }

   Navigation {
     navigationMode: navigationModeTabsAndDrawer

     NavigationItem {
       title: "Home"
       icon: IconType.home
       NavigationStack {
         Page { title: "Home" }
       }
     }
     NavigationItem {
       title: "Favorites"
       icon: IconType.star
       NavigationStack {
         Page { title: "Favorites" }
       }
     }
     NavigationItem {
       title: "Help"
       icon: IconType.question
       NavigationStack {
         Page { title: "Help" }
       }
     }
   }
 }
  • The Felgo Live Client now also supports Bluetooth, NFC and Qt Quick Pointer Handlers.
  • New property labelFontSize of the AppCheckBox to change its font size.
  • Network adapter selection in Live Server: Change the selected network adapter of the Live Server if your mobile Live Client is stuck in the "Connected" screen.

Improvements

Fixes

  • Fixes a potential crash and function evaluating warnings during object destruction if a Navigation and NavigationStack is used from within a Loader item.

v 2.16.1 (2018-05-08)

Highlights Blog Post: Release 2.16.1: Live Code Reloading with Custom C++ and Native Code for Qt

Felgo 2.16.1 features live code reloading with custom C++ and native code for Felgo and Qt projects.

iOS Bundle Identifier Migration

Starting with Felgo 2.16.1, the app's bundle identifier for iOS is set using the PRODUCT_IDENTIFIER setting in your *.pro project configuration. To adapt to the new setting perform the following steps:

1. Open your *.pro project file and add the following block:

 # configure the product's bundle identifier
 # this identifier is used for the app on iOS
 PRODUCT_IDENTIFIER = com.your.company.YourApp

where com.your.company.YourApp matches the CFBundleIdentifier setting of your existing Project-Info.plist configuration.

2. Open your Project-Info.plist in the ios subfolder and replace the value of CFBundleIdentifier with $(PRODUCT_BUNDLE_IDENTIFIER), so that it looks like the following:

 <key>CFBundleIdentifier</key>
 <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>

3. After running qmake, your iOS build uses the new setting.

Note: Make sure to transition your project to this new format, as otherwise app store build uploads from Xcode 9 might fail.

All Felgo Project Wizards already use the new project setting.

Highlights

  • Live Client Module: Live Code Reloading with Custom C++ and Native Code

    Felgo version 2.16.1 introduces the Live Client Module. You can use it to add QML live reloading features to your own application. This allows you to use custom C++ and native code together with live code reloading for QML and JavaScript. You can find a quick integration guide in the update blog post.

Improvements

Fixes

v 2.16.0 (2018-04-10)

Highlights Blog Post: Release 2.16.0: iPhone X Support and Runtime Screen Orientation Changes

Felgo 2.16.0 brings iPhone X support and runtime screen orientation changes.

Felgo Games & Felgo Apps

Highlights
  • iPhone X Support for Felgo Apps

    The iPhone X comes with new UI challenges, as the screen is now bigger and includes reserved areas that hold native buttons or overlays. The Felgo Navigation components automatically adjust their style to match these new requirements. In addition, the Page::useSafeArea setting takes care of keeping your UI elements within the safe area of the screen.

    Alternatively, you can also disable the setting and manually align your content to the Page::safeArea item. The exact pixel insets of the screen are available with the NativeUtils::safeAreaInsets property.

  • iPhone X Support for Felgo Games

    To support existing games on devices with reserved screen areas, the Scene::useSafeArea setting keeps your scene content within the safe area. The Scene::gameWindowAnchorItem reflects this safe area of the screen.

    To provide the best look and experience, you can take advantage of the new Scene::fullWindowAnchorItem. You can then e.g. let your background fill the whole screen, without affecting other parts of the game.

    The exact pixel insets of the screen are available with the NativeUtils::safeAreaInsets property. If used within a Scene, keep in mind that these insets do not take scene-scaling into consideration.

  • Simulation of iPhone X for Debug Resolution Menu

    To speed up development, you can test your UI for iPhone X on Desktop without having to build and deploy for the iPhone Simulator.

    The Desktop simulation for iPhone X also covers the native safe area. You can quickly switch between different devices to see how your app looks like with and without safe area insets.

  • You can now set the preferred screen orientation at runtime from within QML code!

    To specify the global orientation you can use the new property NativeUtils::preferredScreenOrientation. E.g. to lock and unlock your app or game to portrait orientation, you can use the following lines of code:

     import Felgo 3.0
 import QtQuick 2.5

 App {
   NavigationStack {
     Page {
       title: "Orientation Lock"

       Column {
         AppButton {
           text: "Lock to portrait"
           onClicked: nativeUtils.preferredScreenOrientation = NativeUtils.ScreenOrientationPortrait
         }
         AppButton {
           text: "Reset default orientation"
           // Resets to the orientation defined in AndroidManifest.xml / Project-Info.plist
           onClicked: nativeUtils.preferredScreenOrientation = NativeUtils.ScreenOrientationDefault
         }
       }
     }
   }
 }

    You can also specify the orientation per page in apps, using Page::preferredScreenOrientation. Use this example code to show a page fixed to portrait mode:

     import Felgo 3.0
 import QtQuick 2.0

 App {
   id: app

   NavigationStack {
     id: stack

     Page {
       id: page
       title: "Screen orientation test"

       AppButton {
         text: "Push portrait page"
         onClicked: stack.push(portraitPage)
       }
     }
   }

   Component {
     id: portraitPage

     Page {
       id: page
       title: "Portrait page"
       preferredScreenOrientation: NativeUtils.ScreenOrientationPortrait
     }
   }
 }

    These properties only have an effect on iOS and Android and override the default screen orientation defined in your project's Project-Info.plist and AndroidManifest.xml.

  • New improved Felgo Live Server UI and new features.

Improvements
Fixes
  • Allows replacing the contentItem of AppTabButton with custom QML code, which threw an error before.
  • Solves performance issues with AnimatedSprite and TexturePackerAnimatedSprite on Windows.
  • Fixes a bug in FelgoGameNetwork where the user's selected country sometimes got reset on app restart.
  • Fixes a function parameter type issue for MouseJoint::getReactionForce() and MouseJoint::getReactionTorque().
  • NativeUtils::displayCameraPicker() now also supports targeting Android 7.0 and newer. Due to changes in the Android rules for app interaction, if your app uses a targetSdkVersion >= 24 in AndroidManifest.xml, it needs to use a content provider so the camera app can save the image to the app.

    For new projects created in Qt Creator, everything is already configured properly.

    If you have an existing project and are updating targetSdkVersion to 23 or greater, you need to add the following code to android/AndroidManifest.xml inside the <application> tag:

     <!-- file provider needed for letting external apps (like camera) write to a file of the app -->
 <provider
     android:name="android.support.v4.content.FileProvider"
     android:authorities="${applicationId}.fileprovider"
     android:exported="false"
     android:grantUriPermissions="true">

     <meta-data
         android:name="android.support.FILE_PROVIDER_PATHS"
         android:resource="@xml/file_paths"/>
 </provider>

    Additionally you need to create a file android/res/xml/file_paths.xml with the following contents:

     <?xml version="1.0" encoding="utf-8"?>
 <paths>
     <external-files-path name="images" path="Pictures"/>
 </paths>

    Finally, add the following dependencies to android/build.gradle:

     dependencies {
   ...

   implementation 'com.android.support:support-core-utils:27.1.0'
   implementation 'com.android.support:appcompat-v7:27.1.0'
 }
  • Fix a possible warning about missing getPrice()F method in log output when using Soomla Plugin.
  • The default AppButton::radius setting now applies App::dp() for the chosen ThemeAppButton::radius. Similar to other button settings, the border radius is therefore density independent from now on.
  • The FelgoMultiplayer::playerLeft() signal now triggers correctly when a player leaves the game.
  • Fix support for OneSignal push notifications on Android 8.0 devices.

v 2.15.1 (2018-02-21)

Highlights Blog Post: Release 2.15.1: Upgrade to Qt 5.10.1 & Qt Creator 4.5.1 | Firebase Improvements and New Live Code Reloading Apps

Felgo 2.15.1 updates to Qt 5.10.1 & Qt Creator 4.5.1 and adds new APIs for the Firebase Plugin.

Felgo Games & Felgo Apps

Highlights
  • Update to Qt 5.10.1 which contains over 300 fixes and improvements.
  • Update to Qt Creator 4.5.1 which fixes several issues.
  • Firebase Plugin account configuration from QML. This makes Firebase setup easier and you can use multiple Firebase accounts from within the same app.
  • New callback functions for several FirebaseDatabase methods.
  • New Felgo Live Scripting mobile Apps for iOS and Android with project cache. You can now view your old projects on your device, without being connected to the Live Server.
New Features
Improvements
Fixes
  • Fix issue with failing QML imports in Qt Creator.
  • Fixes an issue where games would be always started in fullscreen mode while developing, if previously an app was run in iOS theme.
  • Fix App::isOnline and GameWindow::isOnline property on macOS Sierra and iOS 10.
  • Fix user position and location circle for AppMap with MapBoxGL plugin.

v 2.15.0 (2018-01-25)

Highlights Blog Post: Release 2.15.0: Upgrade to Qt 5.10 & Qt Creator 4.5 | Firebase Data Structures and Queries & Many Improvements

Felgo 2.15.0 updates to Qt 5.10

Qt 5.10 Update Note

  • Qt 5.10 introduced a new TabButton::icon property. The derived AppTabButton type, which also used a property with the same name, now offers the tabIcon property to provide the Felgo icon features.

Felgo Games & Felgo Apps

Improvements
  • The update replaces the default icons used in PictureViewer, PullToRefreshHandler and VisibilityRefreshHandler to better match the platform styles. If required, you can still set your own icons with the available properties.

  • Felgo Live Client window always-on-top is now optional and can be disabled in Live Server.

  • Felgo Live Client now shows error log output directly in error screen if the QML file could not be loaded.

  • Firebase Plugin: You can now read and write complex and nested objects and arrays in addition to primitive numbers, strings and booleans using FirebaseDatabase.

    Example:

     FirebaseDatabase {
   id: firebaseDb

   Component.onCompleted: getValue("public/path/to/my/object")

   onReadCompleted: {
     if(success) {
       //signal parameter "value" can be a nested object/array as read from your database
       console.debug("Read value " + value.subarray[3].subproperty.text)
     }
   }
 }
  • Firebase Plugin: You can now specify your query with the optional parameter queryProperties to the functions FirebaseDatabase::getValue() and FirebaseDatabase::getUserValue().

    Example:

     //use query parameter:
 firebaseDb.getValue("public/bigqueryobject", {
                       orderByKey: true,  //order by key before limiting
                       startAt: "c",      //return only keys alphabetically after "c"
                       endAt: "m",        //return only keys alphabetically before "m"
                       limitToFirst: 5,   //return only first 5 sub-keys
                     })

    See more details about the available query parameters at the documentation of FirebaseDatabase::getValue().

  • Firebase Plugin: You can now access the logged in user's ID token using the new FirebaseAuth::userToken property.
  • Firebase Plugin: You can now disable on-disk cache by using the new FirebaseDatabase::persistenceEnabled property.
Fixes
  • Fixes a Navigation issue that affected the usage of the source property for NavigationItem.
  • If the Navigation is created with a Loader that uses the asynchronous setting, the Android menu button displays correctly again.
  • FelgoMultiplayer::leaveGame() requests are now only sent when in lobby, room or game state. The function does not interfere with ongoing joinLobby requests anymore.
  • Fixes the vertical alignment of SimpleRow's disclosure indicator.
  • Fixed a SyncedStore issue which caused syncing to fail in some cases.

v 2.14.2 (2017-12-06)

Highlights Blog Post: Release 2.14.2: Live Code Reloading with Native Cross-Platform Plugins

Felgo 2.14.0 introduced Felgo Live Code Reloading, which reduces your deployment time from minutes to seconds. Felgo 2.14.2 now adds support for using native cross-platform plugins with live code reloading.

Felgo 2.14.2 adds new SocialView types, fixes the App Navigation issue with signal handlers and updates Felgo QML Live Client apps to the latest versions. With this update, Live Code Reloading allows to run and reload your projects on iOS and Android from all desktop platforms. No native iOS and Android build tools required.

Felgo Games & Felgo Apps

Highlights
Fixes

v 2.14.1 (2017-11-30)

Highlights Blog Post: Release 2.14.1: Update to Qt 5.9.3 | Use Live Code Reloading on macOS and Linux

Felgo 2.14.1 adds Live Code Reloading Support for macOS & Linux Desktop. With this addition, Live Code Reloading now allows to run and reload your projects on iOS and Android from all desktop platforms. No native iOS and Android build tools required.

Felgo 2.14.1 also upgrades to Qt 5.9.3, introduces the new SocialView item for social features like user profile, leaderboard or even a full-featured messenger, and extends the App Navigation capabilities with NavigationItem::showItem.

Felgo Games & Felgo Apps

Highlights
  • Felgo Live helps you boost your development speed, by reloading your project simultaneously on every connected device, within seconds after saving changes to your source code. This reduces the long waiting times for compilation and deployment steps, to only a couple of seconds. You can even test your projects on mobile, without installing native mobile SDKs, only by installing the Felgo Live App on your device.

    This update adds the Felgo Live extension for macOS and Linux.

  • The Qt Charts module is now available with Felgo Live.
  • The SocialView allows to add customized social features to your apps and games, which enables you to boost retention and engagement rates while naturally building up your user base. The conference management app for the Qt World Summit 2017 was built with these services and allows to:
    • Search conference attendees to schedule Business Meetings.
    • Store custom user data like the company or job position, so other users can view the details and find conference attendees that match certain criterias.
    • Log in via Facebook to synchronize your data across multiple devices.
    • Become friends and get in touch with the included messenger.
    • See a leaderboard with a ranking of users that actively work with the app.

    To show a default UI for these social services, the GameNetworkView and MultiplayerView offer with a simple state-based approach. However, the SocialView type uses a different approach to integrate such services in your apps or games and has many advantages:

    • Fully compatible with Felgo Apps: The social view is designed for easy usage with Felgo Apps, which usually provide a stack-based layout with the App Navigation components.
    • Better Customization Options: It is now possible to extend the view with custom UI elements to e.g. show custom user data without having to directly modify the QML source code of the view.
    • Native Look and Feel: The default UI of the new view automatically provides a native style and user experience for iOS and Android.
    • Clean Separation of Sub-Pages: The state-based view types mentioned above are fully self-contained and hold a single instance of each sub-view. This means they are not made for e.g. showing different versions or configurations of the leaderboard or user profile in your app. The SocialView on the other hand clearly separates the view, custom delegates and available social pages. This also allows to introduce new custom social pages that can work with the available social services.

    For a full SocialView integration example, please see the updated source code of the Qt World Summit 2017 demo on GitHub.

  • With the NavigationItem::showItem property, you can now dynamically show or hide menu items from your app's main Navigation. This makes it easy to e.g. show different navigation entries for iOS and Android: 
     NavigationItem {
  title: "Only on iOS"
  icon: IconType.apple
  showItem: Theme.isIos

   // ...
 }
Improvements

v 2.14.0 (2017-11-22)

Highlights Blog Post: Release 2.14.0: Live Code Reloading for Desktop, iOS & Android

Felgo 2.14.0 adds Live Code Reloading for Desktop, iOS & Android. It allows to run and reload your projects within a second on iOS and Android from Windows. No Mac and Android SDKs required.

Important Update Notes for existing Android & iOS Projects

Felgo Kits for Android & iOS

As already done with Desktop platforms and Felgo 2.13, we now use custom Android & iOS packages that make future updates easier. To switch to the new packages, perform these steps after updating the Felgo SDK:

  1. Open the MaintenanceTool and select the Add or remove components option:

  2. Add the Felgo packages for Android and iOS:

    Unselect the Qt 5.9.2 package like shown below:

  3. In Qt Creator, choose the new kit for Android and iOS based on Felgo packages.

iOS Project Migration after updating to Xcode 9

With update 2.14.0, we updated all our wizards to be compatible with iOS apps submitted to the App Store with Xcode 9.

Note: If you still use a previous version of Xcode (e.g. Xcode 8), you can either optionally perform these steps now or perform them as soon as you're updating to Xcode 9. You can still use Xcode 8 or earlier after migrating your project.

To migrate your existing project to the new format, perform the following steps:

1. Create a new "Felgo Apps Empty Application" project from the "New Project" wizard within Qt Creator

2. Copy over the folder ios/Assets.xcassets from the new empty project to your project's ios subfolder.

3. Replace all the icon files and launch images found within Assets.xcassets/AppIcon.appiconset/ and Assets.xcassets/LaunchImage.launchimage/ with your previous project's icons and launch images. Make sure to match all filenames and images sizes.

Note: To get the correct names and sizes you can use the online service https://www.appicon.build.

4. You can now remove all AppIcon*.png and Def*.png files from your ios folder, they are not used anymore.

5. As a last step, open the ios/Project-Info.plist file and remove the keys (and their respective values) CFBundleIconFile, CFBundleIconFiles, UILaunchImageFile and UILaunchImages.

Your project now uses the asset catalog and you're ready for submitting your apps to the App Store with Xcode 9 again.

Felgo Games & Felgo Apps

Highlights
  • Felgo Live helps you boost your development speed, by reloading your project simultaneously on every connected device, within seconds after saving changes to your source code. This reduces the long waiting times for compilation and deployment steps, to only a couple of seconds. You can even test your projects on mobile, without installing native mobile SDKs, only by installing the Felgo Live App on your device.

  • All of our project wizards now support submitting iOS apps & games with Xcode 9. For existing projects, see our short update notes above.
Improvements
  • Fix debugging Felgo projects.
  • Fix storing the last window position if maximized or fullscreen mode is used. Also fix behavior when resizing the window.
  • Fix Google Play Services version mismatch error on Android when using both Firebase Plugin and AdMob Plugin in a project.
  • Fix a possible crash on Android with FirebaseAuth from Firebase Plugin when no credentials are provided during registration and login.
  • Fix a warning with AdMob Plugin on iOS that banner frames are changed from a background thread.
  • Fix Store::printStoreProductLists() for generating the in-app purchase description file for the most recent Google Play Store backend (column names are now required and a new pricing template id column is needed).
  • Add new properties FelgoMultiplayer::stateInternal and FelgoMultiplayer::stateInternalName to detect if the client got disconnected from the server. You can also use the new signal FelgoMultiplayer::error() for handling server disconnection. A server disconnect might happen if the user is taking a phone call (i.e. he is leaving the game) and then returns to the game after more than 10 seconds. To prevent other players from waiting for the idle player, the player gets disconnected. With these new properties and signals, you can notify the user he got disconnected.

v 2.13.2 (2017-10-24)

Highlights Blog Post: Release 2.13.2: Update to Qt 5.9.2 & Qt Creator 4.4.1 | Bug Fixes & Performance Improvements

Felgo 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 and NDK versions. It also stores your previous window position and size to accelerate the development process.

Important Update Notes for existing Android & iOS Projects

As Felgo 2.13.2 is based on Qt 5.9.2, perform these steps after updating the Felgo SDK:

  1. Select the Add or remove components option in the MaintenanceTool and

  2. Add the Qt 5.9.2 packages for Android and iOS. This image shows the initial state before you selected 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:

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

In addition, if you are using Felgo Plugins in your project, update the following files after updating Felgo SDK:

Android

In your android/build.gradle file, change the following lines from

 buildscript {
   repositories {
     mavenCentral()
   }

   dependencies {
     classpath 'com.android.tools.build:gradle:3.6.0'
   }
 }

 ...

 allprojects {
   repositories {
     mavenCentral()
     maven { url 'https://install.felgo.com/maven/' }
   }
 }

to

 buildscript {
   repositories {
     mavenCentral()
   }

   dependencies {
     classpath 'com.android.tools.build:gradle:3.6.0'
   }
 }

 ...

 allprojects {
   repositories {
     mavenCentral()
     google()
     maven { url 'https://install.felgo.com/maven/' }
   }
 }

Changes: com.android.tools.build:gradle version changes from 2.1.0 to 2.3.3 and the maven.google.com maven repository is added.

If your project includes a android/gradle/wrapper/gradle-wrapper.properties file, make sure to update the version from

 distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip

to

 distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip
iOS

If you use the mutli-language translation features of Felgo, add the following snippet to your ios/Project-Info.plist file:

 <key>CFBundleAllowMixedLocalizations</key>
 <true/>

Unless you add that flag, your app will only be translated to the default iOS project language on iOS 11 (usually English).

If you use GPS in your app app, for example if you use the AppMap component, make sure that the following two keys exist in your ios/Project-Info.plist file (adapt the string values to your use case in your app):

 <key>NSLocationWhenInUseUsageDescription</key>
 <string>Display your location on the map.</string>
 <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
 <string>Display your location on the map.</string>

Note: These changes are required to use the latest available features with Android Oreo & iOS 11. As usual, you can create a new empty Felgo project from our wizards or use the Felgo demos to compare your project settings with the expected ones.

Felgo Games & Felgo Apps

Highlights
  • Store the last window position & size on Desktop platforms during development and reload it at subsequent app starts. 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. You can manually enable and disable it with the new App::storeWindowGeometry property.
  • Add support for Qt 5.9.2. The most relevant change is a fix for building Android projects with ndk r16 and higher. For the full changelog of Qt 5.9.2. see here.
  • Add support for Qt Creator 4.4.1. Most importantly, this Qt Creator update adds support for the changes Google made to the Android tools in Android SDK 26.1.1.
Improvements

v 2.13.1 (2017-09-21)

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

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

Felgo 2.13.1 is a free update for all Felgo developers.

Important Notice for macOS and Linux Developers

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

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

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

2.) To also set the new Felgo kit as the default for your future projects, click on Qt Creator / Preferences on macOS or Tools / Options on Linux from the menu bar and select Build & Run. Then select the Felgo Kit and click on the "Make Default" button. Now the new Felgo kit will be the default for all your future projects and it will look like this:

Felgo Games & Felgo Apps

Highlights
  • Add support for Qt Creator 4.4.
  • If you want to send push notifications with the OneSignal Plugin to a specific user from the OneSignal dashboard or from your custom server, the userId property now works properly (it returned an empty string before).

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

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

Improvements
  • Optimize the default AppListView cacheBuffer for better scrolling performance.
  • Add a new property FelgoGameNetwork::defaultUserName. You can use this to change the default username that is shown for players who did not set a nickname before. For example, for apps you could set it to "User" instead of the default "Player".
  • Fix Flurry Analytics plugin crash if no Flurry::apiKey was set.
  • The OneSignal Plugin plugin now uses framework version 2.3.7 on iOS. Make sure to download the latest framework from our PluginDemo here and replace it in your project. This fixes an issue of a potential empty OneSignal::registrationId property (push token).
  • Store the last selected platform from the menu bar on Desktop platforms during development and reload it at subsequent app starts. This accelerates the development process if you simulate different platforms like iOS & Android on your Desktop PC.

v 2.13.0 (2017-08-24)

Highlights Blog Post: Release 2.13.0: Free Rewarded Videos & Native Ads for AdMob and Qt

Felgo 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 earn more revenue from your app! This update also adds support to get the phone contact list and to query the phone number of the device on Android.

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 Felgo version 2.12.2. This is a one-time step required to make updating Felgo versions easier in the future:

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

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

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

Felgo Games & Felgo Apps

Highlights
Improvements
  • AdMobBanner ads now follow global position changes: If the QML element's global position changes as result of a parent's position change, the ad will follow. This enables you for example to add banner ads into ListViews which then scroll with the list.
  • Update Chartboost iOS version to 6.6.0.

v 2.12.2 (2017-08-02)

Highlights Blog Post: Release 2.12.2: Firebase Realtime Listeners & Qt Creator Designer Icons

Felgo 2.12.2 adds support for Realtime Database Listeners to the Firebase Plugin, which allows your app to get notified whenever your data changes. In addition, the recently improved Qt Creator Designer now comes with icons for all Felgo types to let you distinguish the different components more easily.

Felgo Games & Felgo Apps

  • Firebase Realtime Database Listeners: Use the Firebase Plugin to store and sync data in realtime across all clients with the Firebase NoSQL Cloud Database.

    The Firebase Realtime Database is a cloud-hosted database. Data is stored as JSON and changes to the database are propagated to other clients in real time. This update adds new properties and signals to the FirebaseDatabase item, which you can use to add listeners for certain database entries. Your app is then notified immediately after your data in the cloud gets changed - no matter which device, user or application changed the value.

    The following example uses the FirebaseDatabase::realtimeValueKeys property and FirebaseDatabase::realtimeValueChanged signal to keep track of a public database entry newstext:

     import Felgo 3.0

 App {

   FirebaseDatabase {
     realtimeValueKeys: ["public/newstext"]
     onRealtimeValueChanged: {
       if(success) {
         console.debug("Public Realtime Value '" + key + "' changed to '" + value + "'")

         // if newstext got changed -> update AppText to show news
         if(key === "newstext")
           news.text = value
       }
       else {
         console.debug("Error with message: " + value)
       }
     }
   }

   AppText {
     id: news
     text: "" // no news by default, news is loaded from database and always up-to-date
   }
 }

    This example already shows how powerful this new feature can be. As soon as the newstext entry changes in the database, all clients will get notified and replace the old news. As Firebase also supports authentication and user access rules, you could even create a real-time chat with this new feature. The possibilities are limitless!

  • Qt Quick Designer Icons: Since Felgo 2.12.1, it is possible to use Felgo Components with the improved Qt Quick Designer of Qt Creator 4.3. To help you get more out of the designer and quickly find the components you need, this update adds icons for all items available with the Qt Quick Designer:

    For a quick guide how to use the new Qt Quick Designer with Felgo, have a look at our tutorial video:

    Felgo Visual Designer – Highlights Video

    This tutorial video shows how to create mobile apps with Felgo using the Qt Quick Designer of Qt Creator.

    Qt Creator Resolution Independence App Essentials App Navigation Theme

    Get Started | 14min | Essential

    Watch Tutorial on YouTube

v 2.12.1 (2017-07-06)

Highlights Blog Post: Release 2.12.1: Improved Visual Editor & Qt Quick Designer

Felgo 2.12.1 adds improved support for the new Qt Quick Designer of Qt Creator 4.3, which allows to write QML code side-by-side with a visual representation of the code. The designer now better supports rendering Felgo Components and all core components are available for drag'n'drop in the side menu.

Felgo Games & Felgo Apps

Improvements
  • Qt Quick Designer Support: With the switch to Qt Creator 4.3 in the previous update the Qt Quick Designer has become even more awesome. For example, with the split-view feature to design your UI and code with QML at the same time:

    This is why we now improved compatibility of Felgo Components with the Qt Creator Designer, which allows all Felgo developers to fully utlize these new IDE features! All Felgo core components are now available in the side menu of the designer for easy drag'n'drop as soon as you add the Felgo import to your QML file. In addition, the designer now better supports rendering Felgo components. Especially the Felgo Apps Navigation Components have undergone a big improvement regarding designer support.

    Creating amazing user interfaces with Felgo has never been easier!

  • Multiplayer: you can now join the game lobby without joining a game with the function joinLobby(). This way, you have information about the lobby available before joining a game room. You can use this to customize matchmaking, for example you could display the number of currently open game rooms, and let the user select a game to join based on this new information.
    See the properties rooms, playerCountOnServer, playerCountOnMasterServer, gameCountOnServer and the function countOpenRoomsWithProperties() for more details.
  • Switch to a cleaner and brighter version of the Felgo Splash Screen, which better fits a broad diversity of game and app types.

v 2.12.0 (2017-06-22)

Highlights Blog Post: Release 2.12.0: Qt 5.9 & Qt Creator 4.3 Support

Felgo 2.12.0 adds support for Qt 5.9 and the latest Qt Creator 4.3. Qt 5.9 adds many great features like support for gamepads and 3D animations. Qt Creator 4.3 adds a much improved design mode, which allows you to write QML code side-by-side with a visual representation of the code. This allows rapid prototyping of UIs. Some of the Felgo components now also support the Qt Quick Designer and visual development to further accelerate the development process.

Felgo Games & Felgo Apps

Qt 5.9 Support

Felgo 2.12.0 upgrades to Qt 5.9 and Qt Creator 4.3, which allows you to use all latest Qt features in your Felgo projects.

Please note the following points for a successful switch to Qt 5.9:

  • After updating, open the MaintenanceTool in your Felgo SDK installation folder and remove Qt 5.8 from your installed components. Since Felgo is not compatible with Qt 5.8 anymore, it is best to remove these kits.
  • Qt Creator should automatically detect the kits for Qt 5.9, which you can use to build your Felgo projects.
  • To enable one of the new Qt 5.9 kits, click "Projects" on the left side of Qt Creator and enable your desired kit in the section "Build and Run". This image is for Qt 5.8, after the update you'll see Qt 5.9 listed as an option:

  • Qt 5.9 dropped support for MSVC2013 and added support for MSVC2017.
Improvements
  • Some of the Felgo components now also support the Qt Quick Designer and visual development to further accelerate the development process. The supported components include GameWindow, App, Scene, Page, NavigationStack and also others are working.
  • You can use an improved icon-font handling within games and apps and use the latest FontAwesome version 4.7.0 with the IconType component.
  • The Friends View now has an improved UI. You can use the Felgo friends system within Felgo Multiplayer to allow users to send friend requests and then show the friends in a separate section of the leaderboard. You can also use this friend system to allow sending messages only between accepted friends to prevent spam in your in-app messages. This improvement is live in the released card game One Card! for iOS and Android.

  • Use the Navigation::tabs property to access the TabControl within Navigation, which is shown if tabs navigation is enabled.
  • The new TabControl::textFont property allows to change all font properties of the text within tabs.
  • With the AppButton::textFont property, you can now access and modify all font properties of the text within AppButton.
  • The Component Showcase App configuration for ios/Project-Info.plist now includes the NSContactsUsageDescription entry, which is required for NativeUtils::storeContacts() since iOS 10.
  • Use the new Dialog::autoSize property to decide whether the dialog uses a fixed height or a dynamic height based on the Items you add as dialog content.
  • Change the color of IconButton when it is disabled with the new disabledColor property.
Fixes
  • Incorrect warning for publish builds about using DEPLOYMENTFOLDERS is no longer displayed when QRC is actually used instead. This is relevant when protecting your source code for published apps.
  • Reduce the initial engine log output when running an application.

v 2.11.0 (2017-05-24)

Highlights Blog Post: Release 2.11.0: All Monetization Plugins now Free, Plugin Trial & Firebase Qt Plugin

Felgo 2.11.0 adds many changes to Felgo Plugins: all monetization plugins for in-app purchases and ads are now free to use in all licenses! This allows all developers in the Personal license to earn revenue with your app or game, no paid license required.

You can now also use all the other plugins for evaluation in a Trial mode. Integration of plugins is now a lot easier thanks to new wizards for adding plugins with Qt Creator.

The Google Firebase Plugin is a new plugin for user authentication and to access the Firebase Realtime Database.

Felgo Games & Felgo Apps

Highlights
  • Monetization plugins for in-app purchases and ads with the Chartboost Plugin, and AdMob Plugin are now free to use in all licenses!
  • All other Felgo Plugins are now usable for free as a Trial Version for all users. This means you can test plugin integration and start developing with plugins before upgrading to Felgo Pro for full plugin access.

    When you add a plugin a Felgo Plugin Trial Watermark is displayed and an alert dialog is shown when the plugin is used. Specify a GameWindow::licenseKey or App::licenseKey to remove this trial with your Pro plan and to activate the used plugins.

    Choose your plugins and create a license key for your application here. To gain access to all Felgo Plugins, upgrade to Felgo Pro.

  • Plugin Project Wizard: This new wizard allows to create a fresh Felgo Project with sample integrations of the Felgo Plugins you choose to include:

    To create a project using this wizard, open Qt Creator and choose "New Project", then select Plugin Application in the Felgo Apps section or Game with Plugins in the Felgo Games section.

    After choosing the plugins to include, please make sure to perform all integration steps described in the plugin documentation.

    In a similar way, the existing project wizards for Felgo Games and Apps now also support adding Felgo Plugins.

  • Plugin File Wizards: Use the new file wizards for Felgo Plugins to add Plugin Items with example QML snippets to your existing projects.

    To create a new Plugin Item, choose "New File or Project" and choose Felgo Plugin in the Felgo Games or Felgo Apps files section.

    Choose a name for the new item and select which plugin you want to use. Then add the new item to your main QML and run the project to view the plugin example.

    Before you can use the plugin, it is required to perform all integration steps described in the plugin documentation.

  • Add Google Firebase Plugin for user authentication and to access the Firebase Realtime Database.
Improvements
  • Improved Games & Apps Compatibility: You can now use Felgo Apps features like controls and platform themes in your games too.
  • Improved Facebook Integration guide for FelgoGameNetwork.
Fixes
  • FelgoMultiplayer correctly registers for OneSignal push notifications when switching user accounts by connecting or disconnecting to Facebook.

    If players connect with Facebook and allow access to their friends list, they can directly compare scores with their Facebook friends or challenge them to multiplayer matches without the hassle of manually searching for their friends in the game.

  • When closing native alert dialogs, the NativeUtils::alertDialogFinished signal now passes correct values for the accepted parameter.
  • WebStorage::setValue() now correctly triggers the provided callback function.

Felgo Apps

Improvements
Fixes
  • Real Estate App: Adding properties to favorites works again, which was broken due to PropertyCross API changes.
  • Fix visibility issue of NavigationStack pages when transitioning to the previous page with a pop action or back gesture.

v 2.10.1 (2017-02-28)

Highlights Blog Post: Release 2.10.1: Felgo Apps, TexturePacker & Qt 5.8 Improvements

Felgo 2.10.1 improves the OpenGL shader implementation on macOS when using TexturePacker and adds better compatibility with Qt 5.8.

Felgo Games & Felgo Apps

Fixes
  • For iOS and macOS, GameWindow and App now correctly detect the isOnline network connectivity state.

    The update also solves a possible issue on iOS and macOS that blocked the network access of the application after turning Wifi off and on again.

  • Improves detection for the tablet property by changing the diameterInInches calculation for GameWindow and App.

    The threshold for setting tablet to true also increases to 5.3. This prevents tablet layout detection on bigger phones like the iPhone 7 Plus.

  • The settings.language property for GameWindow and App now always correctly reflects the loaded translation. For more information how to make apps or games for multiple languages, see here.
  • Prevents a Qt Creator crash after closing the IDE on macOS.

Felgo Games

Fixes
  • Using TexturePacker components is possible again without shader issues that might caused runtime errors.

  • Solves an OpenGL linker issue when using Spine on Windows Phone and Win RT platforms.

  • The icons in GameNetworkView now display correctly when using the component in combination with other icon fonts.
  • WebStorage initializes and synchronizes the current state with Felgo Game Network at first app startup.

Felgo Apps

Fixes

v 2.10.0 (2017-02-02)

Highlights Blog Post: Release 2.10.0: New App Showcase, Multiplayer & Multi-Language Improvements, Qt 5.8

Felgo 2.10.0 adds a new Showcase App which combines all app demos in one application and adds a new demo with full source code for the most common requirements in mobile apps. Furthermore, Felgo Multiplayer now supports to invite players to running games. You can now add support for multiple languages easier than before. And use all the features like text-to-speech introduced in Qt 5.8 with Felgo.

Felgo Games & Felgo Apps

Qt 5.8 Support

Felgo 2.10.0 upgrades to Qt 5.8 and Qt Creator 4.2, which allows you to use all latest Qt features in your Felgo projects.

Please note the following points for a successful switch to Qt 5.8:

  • After updating, open the MaintenanceTool in your Felgo SDK installation folder and remove Qt 5.7 from your installed components. Since Felgo 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 Felgo 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 section "Build and Run".

  • Qt 5.8 for Android requires the latest Android NDK. You can download the NDK here.
New Features
  • Internationalization support: Felgo now makes it easier to support multiple languages in your app or game. Create your app using default texts and easily support different countries and languages by adding your translations. The correct translation is automatically chosen based on the detected system language of the device. Users can also switch the language manually at runtime - use the new GameWindow::settings.language property to use this feature. See How to Make a Multi Language App or Game with Felgo for more information.
  • SyncedStore: Use this new component together with the Soomla Plugin to 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 Felgo Game Network WebStorage to synchronize the balance of your virtual goods and currency between the user's devices.

Felgo Apps

Highlights

New Showcase App

iOS Android

The improved component showcase covers the most useful Felgo features you might want to include in your own app. Have a look at the full source code in the updated Felgo Sample Launcher or download the app from the stores for iOS or Android.

The updated Component Showcase App combines the most important Felgo Apps features in a single app with native user experience (UX) and fluid UI animations:

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

Android

New Slider Controls

  • Use the new AppSlider or AppRangeSlider controls to choose a value or range with native looks for iOS and Android.

Improvements
Fixes
  • Fix a compatibility issue of AppTabBar with Qt 5.8 which broke the rendering of the tab buttons.
  • Solve issue of AlphaVideo not showing on some Android devices and correctly scales the video when the item size changes.
  • Hidden Dialog and InputDialog instances no longer consume the Android back-button after they are closed.

Felgo Games

Felgo Multiplayer Improvements
Fixes

Felgo Plugins

Improvements
  • AdMob: The AdMob plugin now uses the latest platform SDKs 7.16.0 for iOS.
  • Chartboost: The Chartboost plugin now uses latest platform SDKs, 6.6.0 for iOS and 6.6.1 for Android.
  • Flurry: The Flurry plugin now uses the latest platform SDKs, 7.8.2 for iOS and 6.7.0 for Android.
Fixes

v 2.9.2 (2016-11-14)

Blog Post: Release 2.9.2: Qt World Summit 2016 App Showcase and New App Components

Felgo 2.9.2 comes with the Qt World Summit 2016 app showcase demo, adds a lot of new app components and updates the Facebook Plugin to use the latest available version.

Felgo Apps

Highlights

Qt World Summit 2016 App Showcase

iOS Android

We made a full featured conference management app for the recent Qt World Summit Conference that comes with many new components. Have a look at the full source code in the updated Felgo Sample Launcher or download the app from the stores for iOS or Android.

The Qt World Summit 2016 Conference App allows to:

  • Browse the conference schedule.
  • See detailed information for all talks, speakers and tracks.
  • Manage your personal schedule by adding talks to your favorites.
  • Customize the UI and switch between different native styles and colors.
  • Earn points for each app-start and favored talk to climb the leaderboard.
  • Make friends and send messages with the integrated in-app chat.

The app also shows best practices how to use the Felgo Apps Components to create apps that:

  • Support multiple platforms, screen sizes and screen resolutions.
  • Provide a native look and feel for different platforms from a single code base.
  • Handle mobile app specific requirements like offline capability.
  • Use native device features like confirmation dialogs.
iOS

Android

New Felgo Apps Components

While working on the Qt World Summit 2016 Conference App we also made many new components you can easily use in your own apps:

  • Create native-looking tabs with the new AppTabBar and AppTabButton components that also support a swipe-able content view.

  • Add a search feature by integrating the SearchBar component with Theme-based styles for iOS and Android.

  • Quickly jump to the alphabetically sorted sections of your ListView with the SectionSelect control.

  • Use the AppFlickable to add a native looking rebound effect to your scrolling.

  • Show static or clickable text in your NavigationBar with the new TextButtonBarItem.

  • Add a material-design styled FloatingActionButton to provide quick access to your Android app's most important features.

Improvements
Fixes

Felgo Games

Improvements
Fixes

Felgo Plugins

Highlights
  • Facebook: We upgraded the Facebook plugin to use the latest platform SDKs version 4! There is also a new signal that gives additional information about an opened session, called Facebook::sessionOpened. On iOS, make sure to copy the latest iOS frameworks from here and have a look at the updated integration guide.
Improvements
Fixes
  • Flurry: Fixes a possible crash on Android if no Flurry::apiKey is set.
  • Soomla: Fixes a possible crash on Android if no billing service is set in AndroidManifest.xml file.

v 2.9.1 (2016-08-25)

Blog Post: Release 2.9.1: Multiplayer Enhancements & Plugin Updates

Felgo 2.9.1 is an incremental maintenance update.

Felgo Games

Highlights

Rebranded Multiplayer Card Game

We rebranded our Multiplayer Card Game "ONU". This includes updated graphics for the whole game, custom cards that match the Felgo style and a new game title "One Card!". See the game overview page to learn where to find it in the stores or to have a look at the source code.

The new game version also includes many additional features like a single player mode, medals for high-level players and an increased max player level. It now also showcases the integration of In-App Purchases and Advertisements with the Soomla Plugin and the AdMob Plugin.

New Felgo Multiplayer Features

  • Latency Simulation: The new property latencySimulationTime allows to simulate network latency for messages in your multiplayer game. Use the property during the testing of your game to fix errors coming from delayed messages, that might occur when players have a bad network connection. This is a very important feature for debugging any multiplayer game.
  • Restarting Games: Additional multiplayer functions restartGame() and endGame() make it possible to restart or end a game for all players in the room. To allow handling a new game and a restarted game differently in your game code, the gameStarted(gameRestarted) signal now provides a gameRestarted parameter, which is set to true for a restarted game. The signal gameEnded() informs all players that a game has ended. This feature requires two additional reserved messages codes: restartGameMessageId and endGameMessageId.
  • Single Player Mode: Use the new function createSinglePlayerGame() to start an offline game. For offline games, the initial matchmaking phase is skipped and no other players can join the game. The offline game starts immediately and the leader player can provide AI moves for users that would otherwise be controlled by a person. No messages are sent during the game and everything is handled locally on the device. As you can reuse your already existing multiplayer game logic, this allows to add an offline mode to your game with only little effort. During a single player game, the property singlePlayer is set to true.

For a sample implementation of these new features, have a look at the "One Card!" Multiplayer Demo.

Fixes

Felgo Plugins

Highlights
  • All Plugins on Android now use the latest available Play Services libraries 9.4.0.
  • OneSignal: We updated the OneSignal platform libraries to use the latest versions. On iOS, make sure to copy the latest iOS framework from here.
  • Chartboost: We updated the Chartboost platform libraries to use the latest versions. On iOS, make sure to copy the latest iOS framework from here. This update also fixes video caching issues that prevented loading Video Interstitials and Rewarded Videos.
  • AdMob: We updated the AdMob platform libraries to use the latest versions. On iOS, make sure to copy the latest iOS framework from here.

Felgo Apps

Fixes
  • Fixes Theme font issue that initially caused a wrong font to display on desktop platforms.

v 2.9.0 (2016-08-04)

Multiplayer Introduction Blog Post: Release 2.9.0: Introducing the Improved Felgo Multiplayer Feature

Felgo 2.9.0 adds Felgo Multiplayer for easily creating real-time & turn-based multiplayer games with Felgo.

Felgo Games & Felgo Apps

Qt 5.7 Support

Felgo 2.9.0 upgrades to Qt 5.7 and Qt Creator 4.0, which allows you to use all latest Qt features also with Felgo projects.

Please note the following points for a successful switch to Qt 5.7:

  • After updating, please open the MaintenanceTool in your Felgo SDK installation folder and remove Qt 5.6 from your installed components. The update deletes the Felgo libraries from Qt 5.6 and the old kits do not work anymore.
  • Qt Creator should then automatically detect the 5.7 kits for Qt 5.7, which you can use then to build Felgo projects.
  • Qt 5.7 for Android requires at least a minSdkVersion >= 16 setting. To successfully build your projects for Android, open the file android/AndroidManifest.xml of your project and make sure to set at least:
 <uses-sdk android:minSdkVersion="16" ... />

Felgo Games

Highlights

Felgo Multiplayer is officially released.

Following its successful beta release, you can now access Felgo Multiplayer when you update Felgo – even as a free user. This new feature can be integrated into your game with less than 100 lines of code! For a quick preview of the Felgo Multiplayer features check out the Felgo Multiplayer YouTube Video.

Felgo Multiplayer Features

  • Real-Time and Turn-Based Multiplayer Support: Felgo Multiplayer supports both real-time and turn-based gameplay, so you can use it to make many different types of multiplayer games. It's perfect for making player-vs-player games like 'Words with Friends' or games for a large amount of players, such as 'Clash of Clans'. With Felgo Multiplayer, you can now rival these games and make whatever kind of multiplayer game you like.
  • Matchmaking and ELO Rating System: Felgo Multiplayer includes a matchmaking feature that allows you to play with your friends or join already running games. It also includes an ELO Rating System that matches players against opponents of a similar skill level to ensure competitive gameplay.

  • Friend System and Social Features: Felgo Multiplayer lets you add your friends or make new friends with players you meet in-game. You can also compare your highscore with your friend’s in a dedicated Friends leaderboard. These leaderboards are sure to increase your retention and engagement rates as players compete against friends and international players to reach the top of the rankings.

  • Interactive Chat & Push Notifications: Felgo Multiplayer features a messaging system so you can chat with your friends, even if they’re not online. This makes it easy to discuss games or arrange future matches. Best of all, Felgo Multiplayer sends Push Notifications to players when they receive new messages or game invites.

  • Player Profiles & Cloud Synchronization: Felgo Multiplayer lets you create your own player profile. You can upload a profile picture, set a username and decide if your national flag should be displayed. It’s simple to do and no additional logins are required. Furthermore, all the player data like highscore or earned achievements gets synced across platforms and across devices with the built-in Felgo Game Network cloud synchronization.
  • In-Game Chat: Felgo Multiplayer allows players to communicate during gameplay with an in-game chat feature. Players can use it to discuss game results with one another, message their friends or chat about the latest news with people from all over the world, right in a running game. This feature adds a strong social element to any multiplayer game and creates an engaging experience for young and old players alike.
  • True Cross-Platform: Just like other Felgo features, Felgo Multiplayer is a cross-platform solution. This means that your game will work on both iOS and Android devices, but also that players on iOS devices can play against Android users. Felgo Multiplayer also works on Windows Phone and Desktop platforms, including Windows, macOS (Mac OS X) and Linux.
  • Easy Integration: The Felgo Multiplayer component can be included in your game with less than 100 lines of code. This means that you can integrate this feature into your game in less than 10 minutes. You can use the documentation to find out how to add this feature to your game.

Component Overview

The following table gives an overview of all relevant Felgo Multiplayer components and what they are used for:

Component Description
FelgoMultiplayer Felgo Game Network component to add multiplayer features to your game.
MultiplayerView The default UI for FelgoMultiplayer matchmaking, friend selection, chat and game invites.
NotificationBar Base type for creating a notification bar to show incoming FelgoMultiplayer push notifications in-game.
MultiplayerState Item for handling the possible states of FelgoMultiplayer.
MultiplayerUser Represents a single Felgo Multiplayer user.
NoRanking Can be used as the rankingStrategy to disable the ranking feature.
SimpleRanking Defines a simple multiplayer ranking strategy. It is the default rankingStrategy.

Felgo Multiplayer also integrates seamlessly with the FelgoGameNetwork. For showing leaderboards that include a Friends section or to let the users customize their profile it is sufficient to add a GameNetworkView like you would for games without multiplayer features. Each MultiplayerUser is essentially also a GameNetworkUser with leaderboard scores and achievements.

New Demo Game and Examples

Felgo Multiplayer has already been used to launch "One Card!", a successful 4-player card game based on the popular UNO game. "One Card!" is available on the App Store and Google Play Store and has garnered 100,000+ downloads in the first month. The player retention rates and engagement metrics are also way above the industry standard, thanks to the multiplayer features. Thus you as developers can use the full source code as a best practice for multiplayer integration and create your own multiplayer games within a few days.

The full source code for "One Card!" is available for free in the Felgo SDK. See here for an overview of all game features and to find the full source code of the game.

The new Felgo release also contains two more Multiplayer Examples:

  • Multiplayer Advanced Example - A demo project that uses most of Felgo Multiplayer features in a game where players try to turn the time on a clock to noon/midnight.
  • Multiplayer Simple Example - A simple multiplayer demo where players can ping each other in turn. It uses the Matchmaking and Game Invite system.

All of the demos and examples are included in the Felgo Sample Launcher.

Felgo Apps

Improvements
  • AppMap automatically deactivates GPS tracking when the app is backgrounded to avoid draining battery if the app is not used.
  • Replacing Theme fonts with newer versions of our default fonts caused troubles because a certain font can only be loaded once in an app. The default Theme fonts are now lazy loaded to give priority to custom font definitions by Felgo users.
Fixes
  • If the Navigation item on iOS uses the NavigationDrawer, the menu items do not display a disclosure icon now.
  • Fixed an issue with displaying NavigationItem icons in the NavigationDrawer.

v 2.8.6 (2016-07-15)

Highlights Blog Post: Release 2.8.6: Multiplayer Game "One Card!" & New Native Features

Felgo 2.8.6 adds a new multiplayer card game and new native features like storing a contact in the address book and opening an apps page in the native App Store to help get app store ratings for your app or cross-link to other apps.

Felgo Games & Felgo Apps

Highlights
  • Greatly improve UI of all multiplayer views. You can see the views in action in the new multiplayer card game "One Card!" available in the app stores.

  • Allow joining already running multiplayer games to support more active players in a running multiplayer match.
  • New native features: Store vCard contacts to the device AddressBook with NativeUtils::storeContacts(vCard) or launch apps on the device with NativeUtils::openApp(launchParam). The NativeUtils::openApp() function is useful to get an app store rating for your app or cross-link to other apps.
  • Access the device OS and version with system.osType and system.osVersion and retrieve the device model identifier with NativeUtils::deviceModel().
Fixes

Felgo Plugins

Improvements
Fixes
  • AdMob: Fixes an issue that AdMob smart banners are not correctly displayed on iOS.
  • Chartboost: Android now uses the latest native library that fixes an issue on Android 6.
  • Facebook: Fixes a possible crash after logging in with Facebook app on iOS.

v 2.8.5 (2016-06-16)

Highlights Blog Post: Release 2.8.5: Image Upload to Server and Native Image Picker

Felgo 2.8.5 adds the functionality to upload pictures to our web backend and adds a native image picker from camera or the picture gallery.

Felgo Games

Highlights
Improvements
Fixes

Felgo Apps

Highlights
Improvements
  • The Page::title is now automatically truncated if it is longer than the available width in the NavigationBar. This is only possible if the Page::rightBarItem slot does not hold a NavigationBarRow with enabled showMoreButton setting.
  • It's now possible to use the same Xcode project on iOS for all device and simulator targets without recreating it from Qt Creator for every change.
Fixes
  • If all child items of NavigationBarRow are hidden, the "more button" is now correctly displayed.
  • Fixes AppMap issues when zooming with fitViewportToMapItems while also showing the user position on the map.
  • The new NavigationBarItem::contentWidth property now allows to manually set the width of the item's content area. This fixes binding loop issues with the item width when creating custom NavigationBarItems.

v 2.8.4 (2016-05-26)

Highlights Blog Post: Release 2.8.4: Google Cloud Messaging Integration & Felgo Games Improvements

Felgo 2.8.4 adds the GoogleCloudMessaging Plugin and fixes several minor bugs.

Felgo Games

Improvements
  • Felgo Game Network default views got some styling improvements.
Fixes
  • Fixes rendering issues on some Android devices when displaying rounded user images in GameNetworkView.

Felgo Apps

Improvements

Felgo Plugins

Highlights
Fixes

v 2.8.3 (2016-05-03)

Highlights Blog Post: Release 2.8.3: New GameCenter Plugin and Bug Fixes

Felgo 2.8.3 adds the GameCenter Plugin and fixes several minor bugs.

Felgo Games

Fixes
  • It's no longer required to change the AndroidManifest.xml file for existing projects if you don't use plugins in your project, as it was with update 2.8.2.
  • Fixes a possible error output that module "QtQuick.Dialogs" could not be loaded if using Felgo Game Network components.

Felgo Plugins

Highlights
  • This release adds the new GameCenter Plugin that allows to synchronize scores and achievements from Felgo Game Network to iOS Game Center.
Fixes

Felgo Apps

Fixes

v 2.8.2 (2016-04-27)

Highlights Blog Post: Release 2.8.2: Easier Plugin Integration & Debug Menu Improvements

Felgo 2.8.2 drastically improves integration of Felgo Plugins, as all plugins are now part of Felgo. If you want to use the new plugin integrations please have a look at our migration guide.

Note: Important note for Android users: If you're using our existing projects with Felgo 2.8.2, please perform the changes to your AndroidManifest.xml file as described here.

Felgo Games

Highlights
  • Felgo Plugins are now integrated into Felgo libraries, which makes integration a lot easier. Please have a look at our migration guide for further information.
Improvements
  • We improved the Felgo debug menu to downscale the application window for resolutions that do not fit the screen. This allows to simulate all devices on desktop regardless of the screen resolution.
  • GameNetworkView now automatically fills the GameWindow if placed in a Scene, or its parent item if not.

Felgo Apps

Highlights
  • Felgo Plugins are now integrated into Felgo libraries, which makes integration a lot easier. Please have a look at our migration guide for further information.
Improvements
Fixes
  • Fixes a SampleLauncher issue with Theme initialization when running app demos.
  • Fixes a bug on Android 4 devices that caused the home button to stop working.
  • Corrects a wrong y-position when pushing pages with NavigationStack::clearAndPush.
  • Fixes rendering issues of navigation components on some iOS devices when doing debug builds.
  • Fixes AppMap pinch-to-zoom gesture on mobile devices.

Felgo Plugins

Highlights
  • This release adds the new push notification plugin OneSignal Plugin that should be used as replacement for the Parse plugin.
Fixes

v 2.8.1 (2016-04-07)

Highlights Blog Post: Release 2.8.1: Spine Animations with Felgo & Qt

Felgo 2.8.1 adds support for Spine animations, offers new file wizards and fixes some compatibility issues with Qt 5.6.

Felgo Games

Highlights
  • New wizards and templates in Qt Creator: When creating a new file, you can now select from several templates for Felgo games, such as template scenes.

  • Spine Animations: Convert your Spine animations to QML and use them in your Felgo games! See our new spine guide for more information: How to Add Skeleton Animations by Spine to Your Felgo Game

    There's also a new Spine example in the Felgo Sample Launcher that shows how to use the converted Spine entities. You can find in it the Examples/Sprites category.

Improvements
  • Felgo debug log messages are hidden by default when running qmake on your project (you can still display the messages when setting CONFIG += felgo_debug in your project file).
  • The GameWindow::displayFpsEnabled property now shows the fps at the correct position again if set to true.
  • Fixes issues when using the DEPLOYMENTFOLDERS project variable with Qt 5.6 that caused some builds to fail.
  • Fixes a possible app freeze on iOS when backgrounding a game that uses TexturePackerSpriteSequence.
  • Mac Sample Launcher: Feature to open the source path to an example in Finder is now fixed.

Felgo Apps

Highlights
  • New wizards and templates in Qt Creator: When creating a new file, you can now select from several templates for Felgo apps, such as template pages.

v 2.8.0 (2016-03-17)

Highlights Blog Post: Release 2.8.0: New Getting Started Tutorial, Sample Game & App Example

Qt 5.6 Support

This Felgo release uses Qt 5.6. If you update your Felgo installation through the Felgo MaintenanceTool, Qt 5.6 will be automatically installed in parallel to your 5.5 installation.

If you don't need Qt 5.5 for your custom Qt projects anymore, you should uninstall it by opening MaintenanceTool, select "Add or remove components", uncheck all Qt 5.5 packages in the package tree and continue until finished:

Afterwards, make sure that you are using Qt 5.6 kits for you Felgo projects when opening in Qt Creator.

See here to learn more about the Qt 5.6 features.

Felgo Games

Highlights
  • New getting started tutorial, making the first steps with Felgo easier than ever.

  • New demo game Durdles: A top-down shooter for two players with multiple levels, power-ups and different obstacles and opponents.

    Just browse the latest Felgo SampleLauncher to find the full source code or try the game.

New Features
  • The debug menu for changing the resolution during runtime is now available for all demos and examples in the SampleLauncher.
  • New GameWindow properties screenWidth and screenHeight allow to set the size of the content area within the application window on desktop platforms.

    These properties should be used instead of width and height, which refer to the total window size that may also include the Felgo debug menu bar.

  • The GameWindow property menuBarFelgoEnabled allows to activate or deactivate the Felgo debug menu bar.
Fixes
  • Fixes incorrect Scene scaling when using the debug menu bar.

Felgo Apps

Highlights
  • New App Example & Wizard: The Login Template provides a simple app structure with a login page that ensures that the user is signed in to work with the app.

New Features
  • The debug menu for resolution and theme changing is now available for all demos and examples in the SampleLauncher.
  • New properties App::screenWidth and App::screenHeight allow to set the size of the content area within the application window on desktop platforms.

    These properties should be used instead of width and height, which refer to the total window size that may also include the Felgo debug menu bar.

  • The property App::menuBarFelgoEnabled allows to activate or deactivate the Felgo debug menu bar.
Improvements
Fixes

v 2.7.1 (2016-02-17)

Highlights Blog Post: Release 2.7.1: IDE Improvements, More Code Snippets and Updated Documentation

Felgo Apps

Highlights
  • Debug Menu Bar: For test builds on desktop platforms a default menu bar allows changing the window resolution and the app theme (styling).

  • App Examples: Code Snippets for Apps are now available as individual, standalone example files in your Felgo installation.
New Features
  • AppCheckBox: A new theme-able checkbox control that comes with platform-specific styles.

Improvements

v 2.7.0 (2016-02-02)

Highlights Blog Post: Release 2.7.0: New App Components, Qt Maps Demo & Project Templates

Felgo 2.7.0 comes with lots of improvements for Felgo Apps components: You get new components, wizards and a brand new demo showing how to use map-based features within your apps.

It also adds a platformer level editor that enables you to create your own platform game within days.

Felgo Games

Highlights
  • The New platformer level editor allows you to create your own platformer game within days. You can use it to create levels for your platformer game and balance all game properties while the game is running. This speeds up content creation and production time significantly: you can use the level editing functionality to create levels for your game faster.

    With the new Platformer Demo Game, you can see the full source code of a platformer game with integrated level editor and use it to create your own platformer.

    Thanks to the in-game level editing support, the demo game also includes support for user-generated content: Players can create and share their own levels with other players around the world. This enables you to create a game like Super Mario Maker or Minecraft.

  • The new Camera component allows you to easily add cameras following players/characters and camera control for side scrollers or platformer games. You can also use it for any games with bigger level size than one screen. It supports zooming with Mouse wheel on Desktop and finger pinch gesture on mobile.
Improvements

Felgo Apps

Highlights
  • New open-source demo for map-based apps.

  • New project wizards for getting started with a master-detail view app, a tabbed app or a maps app

New Features
  • AppMap: Complete map view implementation based on Qt Location. Can show user location and use coordinate.

  • IconButton: New button type that uses an IconType as visual representation. The button can be used as push button or toggle button with multiple states.

  • NavigationBarRow: A new feature (property showMoreButton) allows to auto-collapse items in a more menu as familiar from the Android platform. This also includes new properties title and showItem for NavigationBarItem to customize the appearance of individual items within a NavigationBarRow.
  • PageControl: This control displays a row of dots, each of which corresponds to a custom page or other block. The currently viewed page is indicated by a filled dot. You can also set custom icons instead of dots.

  • NativeDialog: It's now possible to show platform-native dialogs as an alternative to custom-styled dialogs with InputDialog component.
  • Page: Individual pages can have a translucent navigation bar when used inside a NavigationStack component, when setting the navigationBarTranslucency property.

Improvements

v 2.6.2 (2015-12-10)

Highlights Blog Post: Release 2.6.2: Android Material Design, New Documentation

Felgo Games

Additional Features:

  • Add sidebar navigation in the online documentation.
  • Open Sample Launcher Demo Projects (.pro files) directly in Qt Creator and not source folder if the Felgo Sample Launcher is running from the SDK.
  • Add XMLHttpRequest Element documentation.
  • Reduce file size of demos by removing hd2 images and Android 3rd party libraries of Felgo Plugins which are not needed as Gradle is used.
  • Add app icon for Windows and Mac project wizards. Update all demos.

Fixes:

Felgo Apps

Additional Features:

Fixes:

v 2.6.1 (2015-10-20)

Highlights Blog Post: Release 2.6.1: Change Native UI At Runtime & Felgo Demos in Qt Creator

Additional Features:

v 2.6.0 (2015-10-02)

Highlights Blog Post: Release 2.6.0: Multiplayer, Felgo Apps, TexturePacker, RUBE

Additional Features:

v 2.5.2 (2015-08-27)

Highlights Blog Post: Announcing Improved App Development with Felgo Apps!

Additional Features:

v 2.5.1 (2015-08-11)

Highlights Blog Post: Release 2.5.1: New Puzzle Game like 2048, New Slot Game and Slot Game API & Advanced Match-3 Game

Additional Features:

Fixes:

v 2.5.0 (2015-07-01)

Highlights Blog Post: 3D Games with Qt 5.5 and New Felgo Release 2.5.0

Additional Features:

API Changes:

v 2.4.2 (2015-06-11)

Highlights Blog Post: Update 2.4.2: New Action & Falldown Sample Games, License Update

Additional Features:

API Changes:

  • Add LineItem::rounded property to get rounded edges at the start and end of the line.
  • Improve visual appearance of Felgo Splash Screen in Free License.

Fixes:

v 2.4.1 (2015-04-02)

Additional Features:

  • Add ChickenOutbreak2 Demo game using the Accelerometer for player control.
  • Add new QML Language Tutorials.
  • Add system.pauseGameForObject() and system.resumeGameForObject() to pause all timers and animations for all children of the given object.

API Changes:

Fixes:

v 2.4.0 (2015-02-04)

Highlights Blog Post: Update 2.4.0: Felgo Sample Launcher, Game Tour & New Platformer Game

Additional Features:

  • Add Felgo Sample Launcher to quickly see all demos & examples from within a single app.
  • Add Felgo Tour to find the best resources based on game genres or app categories.
  • Add Platformer Demo as a new demo for a platformer game like Super Mario.

Fixes:

v 2.3.1 (2015-01-13)

Highlights Blog Post: Update 2.3.1: Felgo Qt 5 Plugin Import Changes, RayCast Support

Additional Features:

  • Dynamic Image Switching now supports per-image file switching with Felgo File Selectors. This means, you can decide to not include an hd2 version of your image to reduce the app size, however the image will then not be crisp on hd2 (high retina) screens. This allows you to decide based on your requirements if app size or image quality is more important on a per-image basis.
  • Add RayCast support to Box2D World.

API Changes:

  • Change the Felgo Plugins import path from import Felgo.plugins.* to import Felgo.*.

Fixes:

  • Fix iOS simulator build, which did not work in previous version because of custom global key handler.
  • Fix offset position calculation of CircleCollider: the x and y position values were multiplied by 2 before.
  • Fix faulty TwoAxisController keyboard handling, introduced with Qt 5.4 support in 2.3.0.
  • Add content scaling support also for low resolution devices with resolutions smaller than 480x320 px.

v 2.3.0 (2014-12-11)

Highlights Blog Post: Update 2.3.0: Full Support for Qt 5.4, Windows Phone & Windows Runtime

Additional Features:

API Changes:

Fixes:

v 2.2.0 (2014-11-06)

Highlights Blog Post: Update 2.2.0: Density Independence & Multi-Screen Support, New Flappy Bird Tutorial & Android Back Button Handling

Additional Features:

API Changes:

  • Set the default width and height of Scene to 480x320 if GameWindowItem::landscape is set and to 320x480 if GameWindowItem::portrait is set. This allows auto-rotating Scenes. You might need to change the logical pixel values of Scene children though for making the best use of available screen space.

Fixes:

  • Fix physics position updating if only the y position of the entity changes.

v 2.1.0 (2014-09-02)

Highlights Blog Post: Update 2.1.0: Major Qt 5 Release, Felgo 2 for All Developers

Additional Features:

Fixes:

  • Add Qt Creator autocompletion files of Felgo C++ items with felgo.qmltypes file.
  • Update plugin autocompletion files to latest plugin versions.

v 2.0.4 (2014-08-06)

Highlights Blog Post: Windows Phone 8 and Windows Runtime Support in Felgo and Qt, Gamescom & GDC Meetup

Additional Features:

API Changes:

Fixes:

  • Remove Q_EXPORT_PLUGIN2 from static Felgo library to allow combining it with other QQmlExtensionPlugin objects in one project.

v 2.0.3 (2014-06-30)

Highlights Blog Post: Update 2.0.3: Big Squaby 2 Update, Qt 5.3.1 Support, AI & Particle Components

Additional Features:

API Changes:

Fixes:

  • Fix documentation of signals for Felgo 2.0.
  • Fix applying Body::torque.
  • Fix support for Scene::scaleMode zoomToBiggerSide and zoomNonUniform.

v 2.0.2 (2014-06-04)

Highlights Blog Post: Update 2.0.2: In-Game Level Editor & more Sample Games

Additional Features:

Fixes:

  • Fix forwarding of global key press detection used for runtime resolution switching.
  • Fix bug in Box2D physics plugin which led to Box2D plugin not working with MSVC 2010 and MSVC 2012 compilers in debug mode.
  • Fix FelgoGameNetwork not working on Windows in debug mode due to Qt v4 JS VM issue.

v 2.0.1 (2014-05-20)

Highlights Blog Post: Big Felgo Update with Qt 5.3 Support

Additional Features:

v 2.0.0 (2014-04-10)

Highlights Blog Post: Felgo 2.0 Release with Full Qt 5 Support

Additional Features:

  • Initial release with Qt 5 support: fully compatible with existing Qt 5 projects and works with all Qt 5 components.
  • Add support for local building, deployment and on-device debugging.
  • Add support for enhancing Felgo with custom C++ / Obj-C / Java code or 3rd party libraries.
  • Felgo File Selectors to improve multi-resolution handling.

API Changes:

  • If you are using MultiResolutionImage in your game, create an own subfolder +hd and +hd2 in your img folder. Then rename e.g. myimg-hd.png to myimg.png and move it into the +hd folder. See the ChickenOutbreak example in the new release how the new folder structure looks like in a real game and see the Felgo File Selectors documentation.
  • Rename the imports from import Felgo 1.0 and import QtQuick 1.x to import Felgo 3.0 and import QtQuick 2.0
  • Not all Felgo components from the latest v1.x are ported to Qt 5 and Felgo v2.0 yet. For a list what is supported, see the current Felgo Games Components Reference.

Note: For a list of all changes between Felgo 1.x and Felgo 2.0 see the Forum Thread How to port existing Qt 4 / Felgo 1.0 games to Felgo 2.0.

v 1.5.6 (2014-04-02)

Highlights Blog Post: Update 1.5.6: New Sample Game "Chicken Outbreak 2", Last Update in Version 1

Additional Features:

Fixes:

  • Fix Android resume behavior if lock screen is disabled and app resumed (was frozen before).
  • Fix NativeUtils::displaySleepEnabled bug on Android: now does not sleep by default, as stated in the documentation.
  • Fix EntityManager::removeLastAddedEntity() which did not use the entityId of the entity to be removed before.
  • Discard FelgoGameNetwork error response if device is already registered for other user. Required to avoid error message when signing up with a new fb user.
  • Improve FelgoGameNetwork backend response handling to correctly check for 4xx and 5xx http errors.
  • Also login player if write permissions are not accepted but only read permissions in FelgoGameNetwork::connectFacebookUser().
  • Improve FelgoGameNetwork Facebook connection error responses.
  • Fix offline detection and storing of failed offline requests in FelgoGameNetwork.
  • Fix calling of FelgoGameNetwork::onFacebookSuccessfullyConnected.
  • Fix blending issue of PolygonItem in combination with flickable items.

v 1.5.5 (2014-02-10)

Highlights Blog Post: Update 1.5.5: User-Generated Content, Level Sharing & Level Store

Additional Features:

API Changes:

  • Only set dragging colliders active if EntityBaseDraggable::inLevelEditingMode is set to true.
  • Update PolygonCollider doc with hint about maximum number of vertices is 8.
  • Change default size for content-scaling to match all aspect ratios from 576x368 to 570x360, which makes it more clear why this exact resolution is used. Also upload a Photoshop template to make designing the background easier.
  • Change default disconnect behavior in ProfileView: show a messagebox the user has to accept for a disconnect. If disconnected, also clear local data as otherwise the player would be in the leaderboards twice when the highscores are not cleared.

Fixes:

  • Fix permanent relogin if facebookId is stored for FelgoGameNetwork user.
  • Do not allow newlines for FelgoGameNetwork::updateUserName() on Android any more and limit allowed characters to ASCII characters.
  • Don't restart BackgroundMusic after app was in background mode if the music was stopped beforehand within the game.
  • Improve FelgoGameNetwork response error handling: if an unrecoverable error is received, do not store this request offline but discard it and continue sending the next requests in the queue.
  • Fix maximum request length of FelgoGameNetwork to be unlimited from about 6kB before.
  • Fix wrong default storage path for DownloadablePackage for packages loaded from dynamically created sources (e.g. /package.php?id=123).
  • Fix ItemEditor initialization if EntityManager::dynamicCreationEntityList is set. Bug existed because of delayed loading of ItemEditor which got removed the entity and EditableComponent in the meantime from EntityManager.
  • Fix resolution changes on Desktop at runtime.
  • Fix WebStorage::clearAll() which only cleared the first key before.
  • Improve font rendering on Windows, so there are no more black outlines visible on bright backgrounds.

v 1.5.4 (2013-12-19)

Highlights Blog Post: How to Increase Player Retention with Felgo Game Network

Additional Features:

Fixes:

  • Enhance font rendering for multi-line texts on iOS, Android & Mac OS X.
  • Fix font rendering on Mac Retina screens.
  • Fix EntityManager bug in EntityManager::storeEntitiesAsJson().
  • Demos run from the Felgo SDK directory on Mac OS X now work again, also if no info.plist given.
  • Fix publishing Mac apps on Mac OS 10.9.1 Mavericks.

v 1.5.3 (2013-12-02)

Additional Features:

Fixes:

  • Fix HTTP 302 redirects for DownloadablePackage item downloads.
  • Display FPS label on iOS 7 test builds again.
  • Fix flickering of screen after resuming an Android app from the background.
  • Fix that BlackBerry 10 custom splash screen images are not copied into final app package.

v 1.5.2 (2013-11-12)

Highlights Blog Post: Update 1.5.2: Android Background Fixes

Additional Features:

  • Add signal handlers BuildEntityButton::onPressed, BuildEntityButton::onReleased and BuildEntityButton::onClicked upcon customer request.
  • Add Particle::running property.
  • Improve performance of Squaby Demo by limiting particle effects and using sprite sheets for all images. Also add in-game performance test.

Fixes:

  • Fix issues when app returned to background on Samsung devices and Android versions higher than 4.2.
  • Fix one-frame-off bug with sprite sheet components and SingleSpriteFromFile and SpriteSequence.
  • Fix line breaks in installation guide for OpenSUSE.

v 1.5.1 (2013-10-03)

Highlights Blog Post: Update 1.5.1: Performance Improvements & Customer Request Additions

Additional Features:

  • Add performance improvement to set fully opaque items invisible to speed up rendering.
  • Add documentation instructions how to use the latest Qt Creator version with Felgo.
  • Add mirrorX and mirrorY property to SingleSpriteFromFile and SingleSpriteFromSpriteSheet.
  • Allow changing of GameWindow::displayFpsEnabled property at runtime as it also has a performance cost to re-create a new texture every frame when the framerate changes.
  • Add signals EntityBaseDraggable::beginContactWhileDragged() and EntityBaseDraggable::endContactWhileDragged() upon customer request.
  • Add a World::timeScale property which allows a bullet time effect, i.e. to slow down or speed up of game objects with constant and correct update rates. Added upon customer request.
  • Add MoveToPointHelper::allowSteerBackward property and set it to true by default which was a fixed value of false before.
  • Add Linux 64 bit support to felgo.prf mkspecs feature file to daily and stable build upon customer request.

API Changes:

  • Android DocumentsLocation is now on external storage instead of internal.
  • Change return of FileUtils::getMultiPathUrl() so the absolute url is returned even if not found (required to find videos or non-qml files or non-images from application binary).

Fixes:

  • Allow size-changing of SpriteSequence items at runtime.
  • Allow changes of Text item font properties at runtime.
  • Set correct size of QML renderer if both cocos and QML renderer are enabled on Windows.
  • Take the musicEnabled setting in GameWindow::settings into consideration when resuming and pausing background music for apps going into foreground/background.
  • Allow size-changes of CircleCollider and PolygonCollider at runtime upon customer request.
  • Fix bug in Storage: now receive a value copy in Storage::getValue() instead of a reference, as otherwise the cached value would be modified.

v 1.5.0 (2013-09-02)

Highlights Blog Post: Update 1.5: Chartboost & AdMob, MinGW, Ubuntu13 and More

Additional Features:

  • Add Ad plugins for Chartboost and AdMob.
  • Add MinGW compiler support for Windows. This simplifies the installer setup, because no Windows SDK is required.
  • Add support for Ubuntu 13.04.
  • Add Flurry plugin for BlackBerry 10.
  • Add full support for resizing applications to arbitrary sizes on desktop with the GameWindow::resizeable property. Add GameWindow::minimizeable and GameWindow::maximizeable properties for improved desktop publishing.
  • Add GameWindow::fullscreen property for fullscreen support on desktop, even changeable at runtime by pressing Ctrl + F.
  • Add translation.useSystemLanguage property to allow to always set the system language and overwrite the custom language setting.
  • Add hints about Custom Splash Screens for builds on build server.

API Changes:

  • Add asynchronous writing to Storage component to not block UI thread while writing. Synchronous Storage::setValue() and Storage::getValue() calls are still possible thanks to cache implementation.
  • Change keyboard shortcuts for changing resolution at runtime from keys 1-7 to Ctrl(Cmd) + 1-7.
  • Change clipping node implementation to use Stencil buffer. This allows nesting multiple clipping items.

Fixes:

v 1.4.0 (2013-07-31)

Highlights Blog Post: Update 1.4: BlackBerry 10, DownloadablePackages, Desktop Publishing and More

Additional Features:

API Changes:

  • Move file IO methods from System to FileUtils.

Fixes:

v 1.3.7 (2013-07-15)

Highlights Blog Post: Heavy Loading Time Improvements, New Synmod Showcase Game, Demo Game Overhaul

Additional Features:

  • Add Fixture::onPreSolve() and Fixture::onPostSolve() Box2d handlers to allow implementation of cloud platforms used in games like Doodle Jump.
  • Add Box2D components for autocompletion from import Felgo 3.0.
  • Add Facebook plugin property accessToken and update to latest Android SDK 3.0.2.
  • Add Utils::captureScreenshotFullscreen() and Utils::captureScreenshot() to take a screenshot and store it in the documents directory. Reading the image is only usable on Desktop platforms at the moment though!
  • Add declarativeView() method to FelgoApplication C++ class to be able to register custom items and declare custom context properties on desktop platforms.
  • Add NativeUtils::displaySleepEnabled property to allow display standby for certain apps.
  • Add label for remaining memory on iOS devices if GameWindow::displayFpsEnabled is enabled.

API Changes:

  • Greatly improve performance of image loading by 80% for SingleSpriteFromFile and SpriteSequenceFromFile.
  • Overhaul the sources of all Felgo demos and remove unused code and old comments.
  • Improve performance of image loading as it is not loaded twice for QML and cocos renderer any more when QML renderer is not active.
  • Add network plugin support to the prf file as it is required for reading the Mac address.

Fixes:

  • Make BuildEntityButton work in a Flickable and add check if position changed in release. Use Flickable::pressDelay for parent Flickable to allow flicking and dragging out entities. Use entityManager.entityContainer instead of scene in BuildEntityButton to remove dependency.
  • Fix keyboard bug with back button on Android: before the keyboard had still focus when back button was pressed and could not be opened again.
  • Pause sound effects when app goes in background, not only background music.
  • NativeUtils::clearCocosTextureCache() now also removes SpriteBatchNodes if they are not held by any existing items. Also fix memory issue for sprites of entities.
  • Set default system language for translated games on Android.
  • Allow storing to SQL database after Storage::onDestruction was called.
  • Fix MultiTouchArea::onSwipeUp and other signal emitting.

v 1.3.6 (2013-06-06)

Highlights Blog Post: Support for Multiple Languages and In-App Purchases

Additional Features:

API Changes:

Fixes:

v 1.3.5 (2013-05-21)

Additional Features:

v 1.3.4 (2013-05-14)

Additional Features:

API Changes:

Fixes:

  • Fix issue with wrong image path in ParticleEditor leading to texture list not being shown on mobile platforms.
  • Fix ItemEditor issue with changing the current editableType the old group was still displayed
  • Disabling new Particle item with settings.particlesEnabled for GameWindow::settings is now possible.

v 1.3.3 (2013-05-07)

Additional Features:

  • Add LevelEditor component to store, load, duplicate, remove and export levels so they can be bundled with the application. The new functionality is added to the LevelEditor example and Squaby demo as a reference.
  • Add ItemEditor and EditableComponent to change properties at runtime and save the settings into a JSON format usable by the level editor. The new functionality is added to the ItemEditor example.
  • Add Store plugin for in-app purchases on Android/iOS.
  • Support multiple languages and create tutorial How to Make a Multi Language App or Game with Felgo. Integrate multiple translations to ChickenOutbreak Demo.
  • Add new BalloonPop Demo game and accompanying tutorial.
  • Add tutorial How to create mobile games with multiple scenes and multiple levels and add project template based on it.
  • Add SpriteSequenceFromFile item that supports sprite animations read from sprite sheets with multi-resolution support. This update also increases the performance of previous SingleSpriteFromFile item and adds support to trimmed and rotated sprites in the sprite sheet for smaller texture sizes. It also supports different pixel formats.
  • Add Clipping item and support the clip property in the Flickable element.
  • Add TextInput item to use a text input field without opening a native input dialog with NativeUtils. Added test is in Examples/FelgoTests/basicTests/TextInputTest.qml.
  • Allow entity creation from entityType and optional variationType in EntityManager and add EntityManager::dynamicCreationEntityList property.
  • Add support for setting the width, height and scale for a MultiResolutionImage.
  • Add application state information of GameWindow with signals GameWindow::applicationPaused() and GameWindow::applicationResumed(). This allows saving the game state when the game is moved to background or put the player to a pause state when returning to the app.
  • Optional config flag for enabling iTunes file sharing.

API Changes:

  • The EntityBase::entityId of entities is now set to a better readable format entityType_variationType_entityCount instead of the verbose entity qml url before.
  • Breaking Change: the internals of BackgroundImage use a MultiResolutionImage instead of the Image element. This change requires 3 background images with -sd, -hd and -hd2 suffix to be available. If you do not want multi resolution support for the background image, you can use a normal Image element.

Fixes:

  • Fix Storage issue: at first application start the SQL database was not initialized correctly.
  • Fix certain cases where an active MouseArea can't ungrab the mouse.
  • Fix anchoring a Box2D Body leading to an assertion, when no width or height is set but just anchoring is used. Bug report available here: https://felgo.com/developers/forums/t/crash-when-using-one-wall-with-anchors/.
  • Support change of color for Text items.
  • When resizing Text elements, the characters were displayed incorrectly with cocos renderer.
  • The Particle::positionType Free now also works if the Particle element is rotated, not only when its parent is rotated.
  • Fix Squaby bugs and cleanup code.

v 1.3.0 (2013-03-07)

Additional Features:

  • Simple demo game from the SimpleNinjaGame tutorial from Ray Wenderlich's website.
  • Particle Editor Demo: Allow saving and loading of files. Add many more particle effects to the existing particles. Add support to Particle element to load a particle effect from a json file.
  • File reading and writing with System::readFile() and System::writeFile().
  • Swipe gesture detection for MultiTouchArea.
  • NativeUtils::clearCocosTextureCache() for removing unused but cached textures from cocos renderer.
  • Simpler project configuration by defining CONFIG += felgo in the pro file.
  • Add widescreen support to ParallaxScrollingBackground by duplicating the images 4 times in total next to each other.
  • Add Utils component that provides often-needed functionality like creating a random value in a given range.

Fixes:

  • Font rendering of cocos renderer on all platforms with support for Text wrapping.
  • Support for umlauts and other special chars (UTF-8) for Text element.
  • Correct Y position calculation of Flickable element.
  • Physics Collider removal issue when an entity was pooled and then reused: the old position applied for the physics colliders leading to an instant remove again.
  • EntityManager issue caused by deferred deletion with auto-generated ids: entities did not get deleted if created with the same id in the same tick.
  • Transparency issue for images without alpha channel in cocos renderer.
  • Add Storage element to the available components and add Storage::databaseName property to it.
  • Improve documentation of Getting Started guides, Documentation Overview and Demo Game Overview by explaining complexity level of demo games.

v 1.2.0 (2013-01-21)

Additional Features:

  • Video item for iOS and Android.
  • Particle Editor Demo for runtime changing of particle properties, also on mobile devices.
  • Particle component.
  • Publishing Felgo Games & Apps guide.
  • Add properties System::logOutputEnabled and System::publishBuild which can be used in QML to use different app ids e.g. for Flurry or Facebook. Logging is enabled by default for test builds, and always disabled for publish builds.
  • Documentation for MultiTouchArea.
  • Z property of sprites can now be changed at runtime with cocos renderer as well. Note that z-ordering only works for sprites in the same sprite sheet.
  • Documentation for GameWindow::loadItemWithCocos().
  • Support arbitrary amount of item hierarchy depth. The limit was 16 before, caused by the OpenGL maximum stack size. There is no limit any more now.
  • Keyboard handling of cocos renderer on Mac: Correctly handle all normal characters from A-Z and special keys like backspace, shift, cmd or direction keys.

API Changes:

  • The transformOrigin of EntityBase is changed to Item.TopLeft from the default value Item.TopCenter, because children of items will always use TopLeft as their default (see the examples and demos).
  • Additional parameter for NativeUtils::displayTextInput(): a placeholder parameter which gets overwritten when the user starts typing and a text property for pre-filled text the user can modify. In previous version, only the placeholder text was possible.

Fixes:

  • Native text input dialog bug on iOS.
  • Font loading on Android for some fonts.

v 1.1.0 (2012-12-31)

Additional Features:

  • Accelerometer support for iOS, Android, Symbian and MeeGo.
  • Keyboard handling of cocos renderer on Linux: Correctly handle all normal characters from A-Z and special keys like backspace, shift, ctrl or direction keys.
  • Z property of Items can now be changed at runtime with cocos renderer as well.
  • Add MovementAnimation::onLimitReached signal handler to check borders with better performance from C++.
  • Add sdk property to Deploying Felgo Games & Apps documentation.
  • Add 2 more orientation options to auto-rotate the display by 180 degrees on iOS & Android: sensorPortrait and sensorLandscape to Deploying Felgo Games & Apps documentation.

API Changes:

  • Breaking Change: Rename PhysicsWorld updatesPerSecondForPhyiscs property to correct name PhysicsWorld::updatesPerSecondForPhysics. All demos, examples and documentation got applied this change - if any of your existing projects are using the old updatesPerSecondForPhyiscs property please rename it.
  • Internal scheduling of physics and MovementAnimation, which leads to much smoother movement and position updating of items using these components across all platforms. The improvement is mostly visible at these demos: VPong and Chicken Outbreak. Physics calculation also changed to a deterministic time step, so all platforms have an equal physics speed independent of their CPU.

Fixes:

v 1.0.0 (2012-12-12)

Additional Features:

  • Documentation for Joints and functional list brief information about components.
  • Plugin support for Flurry and Facebook. Also add GameCenter doc to functional list of components.
  • RopeJoint and WeldJoint support, update Box2D to latest source code version 2.2.2.
  • ParallaxItem and ParallaxScrollingBackground items with documentation and examples.
  • New step-by-step tutorial how to make a game like pong.

v 0.9.5 (2012-10-24)

Additional Features:

  • Add Support for Symbian and MeeGo for accelerated cocos renderer and advanced audio support on these platforms.
  • Add generic plugin support working on all platforms, which are not supported by the plugin initially.
  • Dynamically load Squaby scenes to speed up application start-up time.
  • Add openUrl method in NativeUtils.
  • Add logging support in release builds.
  • Add PolygonCollider.

API Changes:

  • Multimedia API: Remove playIfEnabled(), use play() instead. BackgroundMusic notifies on source changes.
  • NativeUtils API for message and input dialog.

Fixes:

  • Fix linux linking of 32-bit libraries on 64-bit systems and wrong projectinclude files for debug builds of linux, Symbian and MeeGo.
  • Check for maximum texture size when calculating allowed scalingSuffixes in GameWindow, which would otherwise lead to a crash if textures are too big. Add additional parameter "requiredTextureSize" for a contentScalingFileSuffixes.
  • Fix message and input dialog on Android.
  • Close app when calling Qt.quit() in QML.

Limitations:

  • Fonts in CocosRenderer are always black on Mac OS X.

v 0.9.4 (2012-09-05)

Additional Features:

  • Add Linux support.
  • Add support for pooling to EntityManager.
  • Text elements can now be aligned horizontally (left, right, center).
  • Add key-value-based web storage on a server hosted by Felgo with the same API as local storage for easy switching.
  • Add support for entity pooling.
  • Add advanced serialization features of entities for level saving.
  • Add functionality to GamInfo to pause and resume all animations and timers for an object with Gam.pauseGameForObject() and Gam.resumeGameForObject().
  • Add back and menu button for Android and integrate to Squaby and ChickenOutbreak examples.
  • Add key event handling from Cocos renderer for Windows platform.
  • Add mirrorX and mirrorY support for Sprite.
  • Add TechDemo example for performance measurement.

API Changes:

  • Change API of GameWindow by merging the 2 confusing properties settings and userSettings to a single settings and improve their doc with example usages.

Fixes:

  • Fix multiresolution support on iOS&Android and improve performance by setting the correct scale factor when loaded at runtime.
  • Improve performance of SingleSpriteFromFile, by caching the result of the json file instead of reloading it for every batch node.
  • Greatly improve performance of rotating particles in entities, healthbars and size-changing of Healthbars when modifying the alive percentage.
  • Improve performance of MovementAnimation.

Limitations:

  • Fonts in CocosRenderer are always black on Mac OS X.
  • MeeGo currently only supports landscape screen orientation.
  • Particles are currently not visible in QML renderer (Symbian, MeeGo).
  • Custom fonts don't load properly sometimes on Symbian.

v 0.9.3 (2012-08-01)

Additional Features:

  • Add documentation for all components & properties.
  • Add Chicken Breakout demo (side-scrolling game).
  • Add libraries for MeeGo and Symbian (Windows only) for local builds.
  • Add app icon for Build Server builds

Fixes:

  • Change and simplify API of all components
  • Fix particle system bugs

Limitations:

  • Fonts in CocosRenderer are always black on Mac OS X.
  • MeeGo currently only supports landscape screen orientation.
  • Particles are currently not visible in QML renderer (Symbian, MeeGo).
  • Custom fonts don't load properly sometimes on Symbian.
Felgo

Sign Up and Download for Free

By signing up, you consent to Felgo processing your data & contacting you to fulfill your request. For more information on how we are committed to protecting & respecting your privacy, please review our privacy policy.
Already have a Felgo account? Login here.
Want to find out if Felgo is a good fit for your company?

As part of the free Business evaluation, we offer a free welcome call for companies, to talk about your requirements, and how the Felgo SDK & Services can help you. Just sign up and schedule your call.

Sign up now to start your free Business evaluation:

  • Free personal evaluation call
  • Access to all Felgo Business license features
  • Up to 5 hours of free professional services
  • Private Slack channel
  • Priority support via Email or screen sharing
Qt_Technology_Partner_RGB_475 Qt_Service_Partner_RGB_475_padded