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.

After this I wanted to create a nice .dmg file for easy deployment on Mac OS X. Thankfully, this process is not hard either. I found this through the Qt Documentation, but it is actually simpler than it seems thanks to the macdeployqt tool. This is mentioned on the page, but I decided to give a more thorough walk through on how to use the tool here:

1. Build your application
2. In the build directory, run

   macdeployqt yourappname.app -dmg

   macdeployqt is found in the ~/Library/QtSDK/Desktop/Qt/474/gcc/bin folder (if that is where you installed Qt)

3. You should now have a nice yourappname.dmg file in the build directory. Open this up and check that your application runs from there.
4. If everything is working fine, you can do some prettifying of your .dmg file by opening it up using the Disk Utility and converting it to a Read/Write disk image.
5. Open your Read/Write disk image and create a shortcut to your Applications folder. This could either be done by dragging the Applications folder while holding the command key or by creating a symbolic link in terminal:

   ln -s /Applications ./Applications

6. Edit the icon size, background image, etc. by clicking Command + J to open the View Options. Also, use View -> Hide Toolbar and Hide Sidebar to hide the excessive toolbars from the disk image.
7. Close the image and use Disk Utility to convert it back to a compressed disk image.
8. Distribute your .dmg file.

If you need more details about the process and how deployment is performed, have a look in the Qt Docs.

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.

Luckily the Qt developers over at Nokia are aware of this and have released a fix in the latest builds of Qt Creator. To acquire these, go to Qt’s snapshot homepage or just download the 32-bit or 64-bit versions for Linux directly from the build made on 12th of July.

Now you may select to skip the packaging by editing the build steps in Qt Creator.

Be aware that the snapshot versions are in development and may have bugs causing irrevocable data loss. That’s the risk you’ve got to take these days to avoid those bloated packages.

ifconfig usb0 192.168.2.14 up

If you, like me, get tired of doing this you may instead let Network Manager in Gnome do the work for you. First of all, connect your N900 via an available USB port. Next, right click the Network Manager icon and hit “Edit Connections…”.

This window will pop up. Press the “Add” button.

Type in a useful name, such as “N900 via usb”, and leave everything under “Wired” as is. Select the “IPv4 Settings” tab.

Set the Method to “Manual” and click “Add”.

Type in 192.168.2.14 as the address and 255.255.255.0 as the netmask. Leave the gateway blank.

Hit “Apply” and you are good to go!

Next, just click the Network Manager icon and select “N900 via usb”. If nothing went wrong, you should now be connected to your device, enabling you to use Qt Creator to its full extent. The next time you plug in your N900, Network Manager will do the work for you automatically.

Update: Note that if you already have a wired connection, Network Manager might try to connect to this so-called “Auto Ethernet” connection when you plug in. If this happens, just click the network manager icon and select the correct connection.

This might also happen the other way around, connecting to your USB connection with your Ethernet card, which of course won’t work. To avoid this completely, you might want to disable auto-connection for you N900 USB.

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