That’s why you can download Nanoparticles from Android market right now:

Download Nanoparticles from Android Market

In addition, I have been working on a Mac OS X port. This is still somewhat in an early stage, but should work on most machines. You can download the Mac OS X port for free here.

Both these version include the new party mode with new particles and new game rules. This should give you many more hours of fun particle-based gameplay.

I’ve only had a HTC Magic with no OpenGL capabilities available for testing, but still the game is running pretty good. This is giving me perhaps too high hopes about how it will perform on a stronger device, such as a Samsung Galaxy SII. I’ll try to get hold of a device like that soon.

In addition I’ve moved almost all the UI code in Nanoparticles over to QML. This finally makes the menus and game logic separated and also has made it a lot easier to add some transitions and user feedback to the UI elements.

I’ve only got a early alpha version ready at the moment, but I’ll probably need a lot of help testing how the game runs on different devices and setups. I will post back here as soon as I’ve got something for you to play with. Maybe I’ll even push it to Android Market in a not so distant future for early testing.

First of all, you’ll need to enable dbus in your project (.pro) file:

maemo5 {
    CONFIG += qdbus
}

Next up, in your .h file you should add the following to import the DBus headers:

#ifdef Q_WS_MAEMO_5
#include <QtDBus/QtDBus>
#endif

And you’ll need to add a slot for the screen state change:

class GameView : public QGraphicsView
{
    Q_OBJECT
public:
    explicit GameView();

public slots:
#ifdef Q_WS_MAEMO_5
    void screenChange(const QDBusMessage &message);
#endif

...

}

Then, in your .cpp file you’ll need to load the Maemo DBus definitions and create a connection. Do this outside any function to have it statically available.

#ifdef Q_WS_MAEMO_5
#include <mce/dbus-names.h>
#include <mce/mode-names.h>

static QDBusConnection dBusConnection = QDBusConnection::systemBus();
#endif

Next up, in the constructor of your class, we’ll set up the necessary DBus connection and interface:

GameView::GameView()
{
#ifdef Q_WS_MAEMO_5
    dBusInterface = new QDBusInterface(MCE_SERVICE, MCE_REQUEST_PATH,
                                       MCE_REQUEST_IF, dBusConnection, this);

    dBusConnection.connect(MCE_SERVICE, MCE_SIGNAL_PATH, MCE_SIGNAL_IF,
                           MCE_DISPLAY_SIG, this, SLOT(screenChange(const QDBusMessage &)));
#endif
}

And finally, we’ll need to fill the function screenChange with something useful. The example below is from my Nanoparticles game and simply pauses the game whenever the screen is locked.

#ifdef Q_WS_MAEMO_5
void GameView::screenChange(const QDBusMessage &message)
{
    QString state = message.arguments().at(0).toString();
    if (!state.isEmpty()) {
        if (state == MCE_DISPLAY_OFF_STRING)
            gameScene.pauseGame();
    }
}
#endif

If you need to check the screen state during startup, have a look at the extra functions that Diph mentions.

Minimizing the application

First of all, to minimize your application you’ll need to add the following CONFIG line to your project file (the .pro file):

maemo5 {
    CONFIG += qdbus
}

Then, in your .cpp or .h file, you’ll need to include the QtDBus headers:

#ifdef Q_WS_MAEMO_5
#include <QtDBus/QtDBus>
#endif

You may of course skip the #ifdef statements if you’d like DBus for other systems as well, but here I’d like to make this exception only for Maemo. Now, anywhere in your application you may add the following lines to minimize to Maemo’s dashboard:

QDBusConnection connection = QDBusConnection::sessionBus();
QDBusMessage message = QDBusMessage::createSignal("/","com.nokia.hildon_desktop","exit_app_view");
connection.send(message);

This could for example be placed inside a signal that is emitted when the users pushes a dashboard button.

Detecting minimization

If you’d like to detect if the user pressed CTRL + Backspace or any other button to minimize the application, you may do so by adding a changeEvent function to your top-most window. Inside you check the event->type() against QEvent::ActivationChange and test the isActiveWindow() at the same time. Here is an example from the Nanoparticles game:

void GameView::changeEvent(QEvent *event) {
#ifdef Q_WS_MAEMO_5
    if(event->type()==QEvent::ActivationChange) {
        if(!isActiveWindow()) {
            gameScene.pauseGame();
        }
    }
#endif
}

Whenever the game is minimized now, the game is automatically paused to avoid background rendering. The game uses OpenGL to render everything, so this saves the battery drastically.

Enjoy your minimized applications!

There has been missing a native application to access information from Trafikanten on the Nokia N900. Instead it has been necessary to use the mobile version of their websites or maybe even the full version. Even though this is a pretty quick and workable solution, there are several benefits of having a native application available. One that becomes very obvious is the use of GPS to find all nearest bus stops or train stations.

I decided to give it a try in June this year and started by releasing some early versions of what is now named “Journey Planner for Norway” (which is “Reiseplanlegger” in Norwegian). During the summer of 2010 I have been trying to improve the application over several iterations, and feel that it has now come to a point where it is usable and stable enough to get the infamous “Version 1.0″ attached to it.

The application is now finding its way through to the Extras-devel catalogue for Maemo and will be pushed upwards through Extras-testing before it hopefully hits Extras within two or three weeks. In the meantime you might either be a bit careless and enable Extras-devel to use the bleeding edge 1.0 version or head over to Maemo Downloads to fetch the beta which will be automatically updated to 1.0 whenever it is ready.

Below you can check out some more screenshots of the application in action:

The application is developed in C++ using Qt with the Qt Mobility libraries. It should not be too hard to port it to Symbian as well, so I will give that a shot in the future. Symbian users does however already have an option to use the Java application “Trafikanten Sanntid” made by Håvard Tegelsrud.

And of course, you can check out the source code here. The application is licensed with the GNU GPLv3 license.

This error is caused because the linker in gcc is unable to find the functions you have defined in your headers in your actual code. So if you have a header which looks like this:

#ifndef MESH_H
#define MESH_H
 
class Mesh
{
public:
    Mesh();
    ~Mesh();
    virtual void draw();
};
 
#endif // MESH_H

You must at least have these functions defined in your .cpp file:

#include "mesh.h"
 
Mesh::Mesh() {
}
 
Mesh::~Mesh() {
}
 
void Mesh::draw() {
}

After this, make sure you clean your compile environment to make sure no object files are being misinterpreted by the compiler. If you are using Qt or a project with a Makefile, you could just run these three commands (the first only applies to Qt projects).

qmake
make clean
make