Overview of The Carbide.c++ Express IDE 1.0
This document provides the reader with an overview of the Eclipse-based Carbide.c++ IDE 1.0. We will go through the features of the IDE while building a hello world application. It’s assumed that the reader has followed the Getting Started section successfully and is now ready to put the newly installed tools to work.
After launching the Carbide.c++ IDE we will be greeted with a welcome screen giving us different possibilities to explore the features of Carbide.c++, e.g. through tutorials or the platform overview documentation.
You should go through this documentation at a later stage as it provides more detailed explanation of how to use the IDE. We will switch directly to the workbench in which we’ll do the actual development and project management. Jump to the workbench by pressing the icon in the top right corner. You can always return to the welcome screen by using the help->welcome menu options. We’ve now arrived at the workbench window; this can be broken down into several elements:
- C/C++ Project view: This shows the folder structure of our current projects and allows us to navigate the files.
- The Editor: Here we can edit our source files.
- Build Configurations: This view allows us to select the build configuration we’ll be using when building projects.
- The Output window: The output window actually contains three different views.
- Problems: The problems encountered during a build of a project.
- Console: Output from the build process (compiler, linker etc.).
- Properties: Shows various properties for a selected item.
This collection of views/windows is in Eclipse terminology called a perspective. So more precisely we’re now looking at the Symbian perspective. There are other very useful perspectives such as the Debug perspective that contains the windows/views useful during a debug session (e.g. allowing us to inspect variables and breakpoints). We can switch perspectives using Window-> Open Perspective menu items. We’ll be using the Debug perspective in the “Debugging Our Applications” section.
If you’re already familiar with the Eclipse IDE for e.g. Java development you might already recognize many of the elements. Also, a large part of the operational aspects are the same. Now that we’ve gotten the IDE up and running lets move on by creating our first application using the Carbide.c++ application wizards.
Building a Helloworld Application
The application wizard enables us to quickly create a project and get the application skeleton in place. So we can start adding our own code to the project and building killer applications.
To create a new application project select the File->New from the menu bar. We can now choose between a number of different project types. In our case we’ll select the C++ Application for S60 Project. The application wizard will now ask you to fill in a project name (we will use HelloWorld as project name) and choose the application template to use. Here we’ll select the Hello world application for S60 2nd Edition.
The application wizard will now show a dialog containing a list of SDKs and build configurations that we can use for our project. The list depends on the SDKs that we’ve installed and in our case that means the Series 60 2nd Edition Feature Pack 3 will be listed.
The wizard suggests three different build configurations:
- S60 2.8 Emulator Debug: This build configuration is used when building our application for execution in the emulator on our PC. This is very useful in the development phase.
- S60 2.8 Phone (ARMI) Release: This build configuration is used to create binaries suitable for execution on the phone.
- S60 2.8 Phone (Thumb) Release: Another build configuration suitable for the phone.
We will not discuss whether you should use ARMI or Thumb when building for the phone, but as a general rule ARMI will generate the most compatible executable.
We’ll leave the selection unchanged and accept all three build configurations. You can press Finish now as we’ll not make any other changes to the template configuration. If you’re curious, you can press next to see the other possible options, but leave them unchanged for now.
Congratulations you’ve now successfully created your first project using the Carbide.c++ IDE.
Let’s explore our newly created project at bit to see which files and folders the wizard has created for us. By looking at the C/C++ Projects view we can see that a number of folders and files have been created. In the following we take a quick look at the different files and their purposes. For additional information about these consult the SDK documentation.
\src folder: Contains all the source (.cpp) files for our project.
\inc folder: Contains all the header files (.h) and some additional include files namely the .hrh and .loc files. The .hrh file contains command ids (enumeration) which are assigned to menu items (the id allows us to identify which menu button is pressed by the user). The .loc file can be used for localization so that the application can support multiple languages.
\data folder: Contains the resources files (.rss) used in our application. A resource file is used for defining a number of UI elements such as menus, dialogs, caption of the application and so on.
\aif folder: Contains application icon files (.bmp), and additional resources files containing information about the application.
\sis folder: Contains the installation information file (.pkg) which is used for creating the application installation file (.sis) containing our final application. The .sis file can be sent to our phone in order to install our application.
To edit a file, simply double-click it and it will be opened in the editor window. Try it out and let’s move on to build the application. We can start a build in two ways: from the Project->Build Project menu options or simply by right-clicking the project in the C/C++ Projects view and choosing Build Project.
The building workspace dialog will now appear and our hello world application will be built using the chosen build configuration. As we haven’t changed anything, the application will be built for execution in the emulator.
To test that everything works we have two options: we can run the application for functional testing or we can run the application in debug mode. We will just run the application for functional testing without debugging facilities (breakpoints won’t work here). The next section will show you how to debug the application using breakpoints. In order to run the application, we need to create a “run as” configuration. This can be done by right-clicking our project and selecting Run As->Run… option. This will bring us to the run configuration window. Here we simply create a new run configuration and press the run button to start the emulator. Starting the emulator can take quite some time, so have patience. Once the emulator is launched, locate our application and open it.
You can read more about using the emulator in the SDK documentation and in the Carbide.c++ help in the Help->Help Contents menu option.
Now exit the application and close the emulator and let’s try the debugging facilities.
Debugging the Hello World Application
A very useful feature of the Carbide.c++ Express IDE is that it allows us to debug our application by setting breakpoints at executable code and e.g. inspect variables to diagnose problems. Let’s try the debugger by setting a break point in one of the source files. Open the HelloWorldAppUi.cpp file in the editor by locating it in the \src folder and double-clicking it. We now need to chose a suitable location for a breakpoint e.g. in the HandleCommandL() function. This function will be called whenever the user presses a menu item in our application. We can set the breakpoint by right-clicking the bar in the left side of the editor window and selecting the Toggle breakpoint option.
We now need to run the application in debug mode. To do this we need to create a debug configuration. Just as we did using the normal run configuration, we just right-click the project folder in the C/C++ Project View and select Debug As->Debug… We now create a debug configuration by selecting new, and start the debug session by pressing the Debug button. This will open the emulator and automatically switch us to the debug perspective. We placed the break point so that it would be activated if we select the Test menu option in our application. As soon as the breakpoint is activated, the Carbide.c++ debug perspective will be activated.
You can now start e.g. inspecting variables and stepping through the code execution. When we’ve done debugging, we can resume execution by pressing the resume button. We now know how to build the application for the emulator. Let’s try to do it for the phone.
Deploying the Application.
In order to deploy the application on an actual phone we only need to change the build configuration. This can be done by pressing the “Select Build Configuration” button. We can now choose between the available configurations. We’ll choose the S60 2.8 Phone (ARMI) Release configuration. The new build configuration is now highlighted.
As when building for the emulator select the Project->Build Project menu option, this will create a new file in the \sis folder, namely the HelloWorld.sis (Software installation script file). The easiest way to install the application on a phone is to use the Nokia PC suite application installer and a Bluetooth dongle. Make sure your PC Suite is connected to your phone and then simply double-click the .sis file in the C/C++ Project view and the PC Suite application installer will be activated and allow you to install our application on the phone.
Complete the installation on the phone. You can find and run the application on the phone by going to the “My own” folder in the phone menu, where you should be able so see the newly installed application.
You now know the basic features of the Carbide.c++ Express IDE, and can start creating your own applications. If you want to get started right away you can find the expanding the application document here. This describes how we modify our HelloWorld application so that it will speak to us (currently under development).