For some time, Qt has provided its own IDE, including an excellent source code editor, integration with existing compiler, debugger, and linker tools. Called Qt Creator, it is itself written in Qt, although it has some features that make using the environment quite comfortable for anyone familiar with Eclipse. More recently, Nokia began providing its own mobile-centric version of Qt Creator, called the Nokia Qt SDK. Available on Macintosh, Windows, and Linux, the Nokia SDK provides the standard suite of services for an IDE, as well as:

In practice, most IDEs today offer the same set of features, and learning to use an IDE is mostly a matter of figuring out which menu contains which commands, and learning (or rebinding) which function keys do what. The Nokia Qt SDK is no different; if you've used Eclipse or Visual Studio, you will feel right at home in a matter of hours.

The Nokia Qt SDK is truly cross-platform, running on Mac OS X 10.6 or later, Linux (Nokia recommends Ubuntu), or Windows (Windows XP Service Pack 2, Windows Vista, or Windows 7). The installation is not small. Expect it to consume about 4 GB of disk space, and it'll happily consume all the RAM and processor you can throw its way. There are some limitations on the Linux and Mac OS X version of the SDK, so be sure to check the documentation; these limitations center on the ability to cross-compile for Symbian and the SDK's use of a Nokia-hosted compilation cloud to enable cross-platform development to Symbian on these platforms. (One of us is happily running the Nokia Qt SDK in a virtualized Windows XP machine on his Mac OS X workstation, so virtualization is also an option.)

The Nokia Qt simulator is an essential part of the SDK that is written as a Qt runtime, emulating key device features. These include device status (such as battery, network access, and screen orientation) and device data (including device location and contacts data), as well as a device's specific Qt implementation of the screen and user interface. Not a device emulator and not a device skin, the simulator provides a fine balance between start-up and debugging performance with the ability to do things such as script device data with JavaScript to enable most debugging right on your development workstation. This eliminates much of the need for source-level debugging on your hardware target, which is still supported for the occasional pesky bug that materializes only on hardware.

Nokia provides web-based and full installs of the Nokia Qt SDK at /www.forum.nokia.com/Develop/Qt/Tools/. (If it's not there, click the Develop tab, then the Qt item in the dropdown menu; once there, choose Tools, and follow the links to the Nokia Qt SDK's download page.) The online installers are pretty small (on the order of 20 megabytes or so), but what you save in the initial download you pay later when the installer downloads the half-gigabyte to gigabyte of tools, headers, and libraries you need for a full installation. The installer itself is easy to use, but budget ten or twenty minutes for the installation; as you might imagine, there are a lot of files and tools to install.

Once you complete the installation and run the Qt SDK for the first time, you see a screen that looks like Figure 3-1. Before you dive in and begin cutting code, however, let's take a few minutes and configure your test hardware. In the discussion that follows, we assume you're working with a PC running a variant of Microsoft Windows; Mac OS X and Linux instructions can be found with the Nokia Qt SDK for those platforms and are similar in substance:

Figure 3.1. The Nokia Qt SDK

While the process sounds complicated, it takes only a few minutes.

Configuring a Symbian Device to Work with the Nokia Qt SDK

With your Symbian device should have come a copy of Ovi Suite, the software that enables a Symbian phone to communicate with your PC. Assuming you've installed it, you need only follow the links in the Nokia Qt SDK folder in your Start Menu to install SQLite, Qt for Symbian, and TRK, the Symbian debugger, and you're set (Figure 3-2). With the Nokia SDK installed, go to the Start menu and choose Start

As you do this, you should have about 20MB free on your Symbian device. As I write this, commercially available devices don't have Qt installed, so it's important that you install everything. By the time this book reaches you, newer devices will have Qt installed, and you need to install only TRK. If you're unsure, check Forum Nokia for specifics about the hardware that you have.

TRK is the debugging stub for Symbian development, and you'll need to have it running anytime you want to debug your application (including just downloading your app more quickly than packaging the application and installing via the application installer). Connect your device to your workstation using USB, and then launch TRK on the device. Choose "Settings," and then choose "USB."

Figure 3.2. Installing TRK on Symbian

Tip

TRK also supports a Bluetooth connection, but the support may or may not be available with the version of the Nokia Qt SDK you have. It's worth checking into, although for long debugging sessions, we recommend that you stick with USB, which usually keeps your handset powered as well.

Configuring a MeeGo Device to Work with the Nokia Qt SDK

With MeeGo, the work is a little more involved, because you're going to use MeeGo's networking stack to connect via TCP/IP over USB or WiFi to your development workstation. Follow the steps included with the SDK, which should show you how to:

• Install the latest Ovi Suite or PC Connectivity Suite from Nokia for USB support on Microsoft Windows.

• On the MeeGo device, select the Application Manager, then Download, then Development, then find Mad Developer and install it. This client application lets you configure a network connection to your development workstation.

• Launch Mad Developer. You will see a screen similar to Figure 3-3.

• To connect using WiFi, activate WiFi on your MeeGo device, and make sure you're connected to the same network as your development workstation. Note the IP address in the wlan0 row of Mad Developer.

• To connect using USB, touch "Edit" on the USB row and confirm by touching "Configure." Note the IP address in the usb0 row.

You'll use Mad Developer any time you want to connect your device to the Qt Creator SDK. Later, in the section titled "Compiling and Running Your Code on a Device," we show you how to complete the workstation half of the connection in the Nokia Qt SDK. Figure 3-3 shows Mad Developer in action.

Figure 3.3. Mad Developer

Tip

Wireless debugging via WiFi is really cool, and works as long as you can ping between your development workstation and the device (that is, they need to be on the same logical network, but not necessarily the same physical network). However, USB is often a trifle faster, and connecting to USB usually powers your handset, too.

Returning to Figure 3-1 for a minute, let's get oriented with how the IDE is organized. When you first start the SDK, the large empty area with the Qt Creator box in the middle is a content area, where you spend most of your time editing visual layouts, source files, debugging, and so forth. Along the left hand side are selectors to different views the IDE can provide. (If you've used workspaces in Eclipse, the purpose is the same.) From top to bottom, the views are:

At the bottom of the left-hand side are progress annunciators for things like source code indexing, as well as four buttons:

Let's create our first Qt application — "Hello World," Qt style.

Let's add a label containing the text "Hello World" and a button, stacked vertically.

You should now see something like the contents of Figure 3-7.

Figure 3.7. Application design.

Before continuing, let's see what the IDE has put together for us behind the scenes. Choose the edit view, and double-click "HelloWorld.pro" from the left hand column. You should see something like the contents of Listing 3-1.

#-------------------------------------------------
#
# Project created by QtCreator 2010-08-04T19:40:08
#
#-------------------------------------------------

QT       += core gui

TARGET = HelloWorld
TEMPLATE = app


SOURCES += main.cpp
        helloworld.cpp

HEADERS += helloworld.h

FORMS   += helloworld.ui

CONFIG += mobility
MOBILITY =

symbian {
    TARGET.UID3 = 0xec6083f7
    # TARGET.CAPABILITY +=
    TARGET.EPOCSTACKSIZE = 0x14000
    TARGET.EPOCHEAPSIZE = 0x020000 0x800000
}

This is your application's project file (also called a pro file, because its suffix is .pro), and defines the libraries your application links to, the source files that need to be compiled, and so forth. As we go along in the book, you'll learn to make small, targeted changes to this file (say, to add a library or an application icon), but in general, you probably won't need to edit it much, because the IDE does most of the heavy lifting. The project file is the input to qmake, Qt's metamake utility is responsible for analyzing project dependencies and coming up with a make file used by a specific platform's SDK, such as MinGW, the Symbian build chain, or the GNU cross-compilation tools for MeeGo. It's declarative in that you specify values for variables (such as SOURCES, a list of the source files from which your application builds), and qmake figures out the rest.

Next up is the "Forms" folder, which contains one file: the file you've been working on in the Qt Designer. The Qt Designer creates the XML you see in the form files that bear the .ui extension. The Qt Designer represents the interface as XML, so you shouldn't edit the XML directly. At compile time, these files get converted to C++ class declarations for your UI. That gives you the flexibility of a visual designer at development time and the performance of carefully tuned C++ at run time, so that there's no latency in setting up a complicated application UI.

The class header file "helloworld.h" defines a single QObject, extending Qt's QMainWindow class (Listing 3-2).

#ifndef HELLOWORLD_H
#define HELLOWORLD_H

#include <QMainWindow>

namespace Ui {
    class HelloWorld;
}

class HelloWorld : public QMainWindow
{
    Q_OBJECT

public:
    explicit HelloWorld(QWidget *parent = 0);
    ~HelloWorld();

private:
    Ui::HelloWorld *ui;
};

#endif // HELLOWORLD_H

The application's main window contains a central widget, which holds the controls for your application's user interface. (As you'll see in Chapter 6, you can actually swap in and out different collections of widgets, letting you show different screens in the same window.) The Qt Designer constructs this widget from the controls you've drawn out, using the XML and the automatically generated C++ we mentioned previously. This declaration of the user interface is done in your application's Ui namespace; as you see in Listing 3-3, you can access the compile-time-generated user interface components in that namespace.

#include "helloworld.h"
#include "ui_helloworld.h"

HelloWorld::HelloWorld(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::HelloWorld)
{
    ui ->setupUi(this);
}

HelloWorld::~HelloWorld()
{
    delete ui;
}

There's a direct binding between the Designer's controls and your source code; if you return to the Designer, select a widget (say, the push button) and look at the right-hand side of the window (Figure 3-7). You'll see a list of properties for the widget you've selected, including the object's name. You can access the widgets in the Ui:HelloWorld class directly just by referencing their name, like this:

ui ->pushButton ->setText("Yo.");

Try this in helloworld.cpp, just after the call to ui ->setupUi(this). (You may need to compile your application first, if you're relying on name completion in the source editor.)

At this point, it's worth a quick compile-build cycle, just to see what you've created. Click the green Run button (the green arrow) at the bottom of the left-hand pane, and the IDE will compile your application and start it in the Qt simulator (Figure 3-8).

Figure 3.8. Hello World, compiled and running in the Qt Simulator.

Before you continue, we urge you to stop, put down the book, and spend an hour or so experimenting with Qt Designer and this sample application. Try:

The Qt Creator is a powerful tool, and with it you can accomplish an awful lot right out of the box — without writing a line of code. Think of the time you spend playing with it now as a small investment that will reap rewards later when you sketch out or build your killer application's user interface.

Before we get to the nitty-gritty of running your code on a device, let's spend a couple more minutes looking at the Qt Simulator. The simulator has two windows — the window showing what your application will look like on the device, and a second window that lets you control the behavior of the simulator itself. This second view is divided into several auto-hiding panes; choose the View pane, open it, and try choosing a different device or adjusting the zoom level. As we write this, you can simulate Maemo, Symbian touch-enabled devices, and non-touch devices, which together span Nokia's platforms that support Qt. Other panes let you simulate various properties of the device, such as its battery level, position, network availability, contacts in the contacts database, and so forth. Much of this is important when testing applications that use Qt Mobility, which we discuss in Chapter 5.

Returning to the IDE, choose the Projects icon from the left-hand pane, and see the different build configurations for your project (shown in Figure 3-9).

Figure 3.9. Setting build configurations for your project

You configure a specific build target here; for example, let's look at getting your code up and running on a MeeGo device. (First, be sure you've installed Mad Developer on your MeeGo device.)

After a short pause while the IDE rebuilds your application for MeeGo, you'll see the application running on the device.

The device's developer account and password work well if you're only going to do a quick test with a device, but for regular work, you're much better off creating a secure shell (SSH) key pair and installing the key on the device. To do this:

Running your application on Symbian devices is even easier:

The Qt IDE will recompile your application for Symbian, copy the application to the device, and start it.