Qt for the Symbian Platform (Product Overview)
From Symbian Developer Community
This article is primarily for Symbian C++ developers who want to understand how Qt can improve their productivity, extend the market for their applications, and enable the creation of applications that would be difficult or near impossible to write using native Symbian C++. Desktop Qt developers may also find it of value in explaining the benefits and challenges of porting to the Symbian platform.
The article focuses on a few Qt features that are likely to be of most interest to Symbian platform developers; if you want to know all about Qt then the best place to start is the Qt 4.6 white paper on the qt.nokia.com Web site. If you just want to get started with Qt on the Symbian platform, then see the Qt Quick Start.
Contents
|
Introduction
The Symbian platform is an open-source software platform for mobile devices. The platform was created in early 2009 based on Symbian OS and contributions from the S60, UIQ and MOAP(S) UI platforms. Symbian OS is shipping in nearly three hundred million devices and more than 250 networks (Canalys, Q2 2009).
The platform's native programming language is Symbian C++, a variant of C++ that has evolved specifically to address the needs of resource constrained mobile devices. Symbian C++ uses programming idioms and frameworks that promote robust and memory efficient code - for example, it has its own exception handling mechanism. Symbian C++ omits certain standard C++ features that were not available (or considered too heavy-weight) when it was created in the mid 1990's.
While a focus on robustness and memory efficiency makes a great platform for mobile devices, it doesn't lead to the easiest programming environment for application developers. Symbian C++ is relatively difficult to use, because its APIs prioritize resource efficiency and provide a high degree control/flexibility to programmers at the expense of simplicity. Developers that are only familiar with standard C++ have a steep learning curve to familiarise themselves with new programming idioms and APIs, different tools, smaller pool of examples and a smaller developer community from which they can seek help.
Qt is a cross-platform application and UI framework that allows developers to write applications that can be deployed to desktop, mobile, and embedded operating systems without need to rewrite the source code. Qt is a superset of standard C++ so developers can use either Qt's or standard C++ types, or a mixture of both (on the Symbian platform Qt is layered over Symbian's standard C/C++ compatibility layer). Qt is already used by hundreds of thousands of developers, and is notable as the framework used in the popular linux KDE desktop, Google Earth and Skype. Migrating Qt applications to the Symbian platform is often no more difficult than a recompilation.
Programming with Qt is easier than with Symbian C++ because it exposes higher level APIs, written to provide simple access to the functionality needed for the most common use cases. Symbian C++ developers usually find it easy to migrate to Qt, and can often create more complicated applications more quickly within a few months; the discipline that comes from working in a resource constrained environment translates well to working with Qt's more developer-friendly APIs.
Qt also opens up opportunities to Symbian C++ developers that would be difficult (at best) with native APIs. For example, QtWebKit enables applications that mix C++, web pages, and scripting environments, while the Graphics View Framework allows thousands of items to be rendered and animated, with all the complicated transformation, collision detection and user interaction being handled by Qt.
The vast majority of applications do not need to use Symbian C++ directly, and the list of tasks for which Symbian C++ is required is rapidly shrinking thanks to the Qt Mobility Project APIs. However if developers do want to access platform-specific functionality, they can find out how in the article: Using Qt and Symbian C++ Together.
Qt runs on Symbian platform devices, and on Nokia S60 3rd Edition, FP1 (and later devices). Qt may be automatically deployed using the "Smart Installer (beta)" (when needed by an application), or delivered as an embedded SIS file. From April 2010 Qt has started to appear in the firmware of Symbian-devices (Nokia N8). Eventually Qt will fully replace the native Symbian C++ GUI layer (well-known to S60 developers as Avkon).
As Qt is a cross-platform application and UI framework, Qt applications written for the Symbian platform will also run on other mobile platforms supported by Qt, and indeed desktop platforms.
The article outlines some of the features of Qt on the Symbian platform, covering the subset of frameworks that are of most interest to mobile developers, the development toolchain, and its vibrant developer community. The paper also outlines some of the functionality we can look forward to arriving in the not-too-distant future.
Key Benefits
Cross Platform Development
Applications written using only Qt and standard C++ APIs should compile and run on any of the platforms that Qt supports. At the moment, Qt is supported on the Symbian platform (and on Nokia S60 platforms from 3rd Edition, FP1), desktop Windows and Windows CE, Mac OS X®, Linux® and Embedded Linux, and all major Unix variants. The full list of supported platforms is given here.
 | Note While applications will compile and run on both mobile and desktop platforms, some porting effort may be needed for them to run effectively. Mobile specific screens may be needed as less widgets can physically fit on the screen, and the presence or absence of a pointer device alters the best way to interact with an application. |
Applications that use platform-level functionality will need some porting effort. Developers that want or need to use Symbian platform specific APIs can find out how in the article: Using Qt and Symbian C++ Together.
Memory management
Objects and Object Trees
Qt applications use an object model that simplifies the management of object ownership (where ownership implies a "responsibility for deletion").
Objects may be added to other objects on construction, and Qt then ensures that all children are automatically owned by, and deleted with, the parent. If a child is deleted before the parent, then it is automatically removed from the parent's list of children, thereby avoiding double-deletion errors. This mechanism extends well to the needs of GUI objects: widgets own all their child objects, and Qt ensures that they are drawn and deleted as needed.
 | Tip When objects are declared on the heap they can be created and added as children in any order. When creating child objects on the stack the parent object must be created before the child; this ensures that the child is deleted and removed from the parent before the parent is deleted (otherwise the child would be deleted twice). |
Objects are not forced to be part of an object tree. They may be declared on the stack as automatic variables or as heap based objects that are "manually" owned and deleted by a parent in the "normal" way. An object can also be locally scoped and heap allocated, as long as a smart pointer like QScopedPointer is used to to ensure the memory is deleted when object pointer goes out of scope.
C++ objects that are managed in this way must derive from QObject. The Object model is covered in detail in the topics Object Trees and Object Ownership and Qt Object Model, and in C++ GUI Programming with Qt 4, Second Edition, Jasmin Blanchette and Mark Summerfield, Prentice Hall (2006) (the first edition is available free online here).
| Note Compare this approach with normal C++ - ownership is hard-coded in the parent, which must manually delete all its owned objects (forgetting is a source of many memory leaks). Consider also Symbian GUI controls - developers must implement two functions in a compound control just to ensure that child controls are drawn. |
Implicit sharing
Qt also uses a mechanism called implicit sharing to manage and share the memory used by value types. Consider QPixmap, a class used to manipulate images. The following code looks like programmatic suicide to a Symbian C++ developer - allocating a big object like a bitmap on the (small and fixed size) stack:
QPixmap p1;
p1.load("image.bmp");
In fact QPixmap is more like a Symbian R class. The object is a reference-counted pointer to a bitmap that is allocated on the heap. Copies of the object increment the reference count - the data itself is only copied when a change is made. This approach allows shared objects to be passed around by value rather than pointer or reference, and ensures that they are automatically cleaned up when all handles are deleted. For more information see the topic: Implicit sharing.
Exception Handling
Qt supports standard C++ exception handling for third party code.
| Note Other than throwing std::bad_alloc on allocation failure, Qt itself does not use C++ exception handling. It does not define, throw, or catch exceptions - instead errors are usually defined on a component-local basis and returned by value. |
Qt 4.6 promises basic exception safety (component invariants are preserved and no resources are leaked) for Qt's container classes as well as for the QFile class. Applications can throw and catch exceptions, including std::bad_alloc thrown by std::new() on allocation failure. Note that any uncaught exceptions will lead to application termination.
Developers are expected to use the macros QT_TRY, QT_CATCH, QT_THROW, and QT_RETHROW instead of try, catch, throw as these ensure that exception handling code is only compiled on platforms that support it. Qt provides the QScopedPointer smart-pointer to allow clean up of locally scoped objects in the event of an exception.
Symbian C++ uses its own Leaves & TRAP exception handling mechanism. When using Qt and Symbian C++ together developers need to create barriers between the two exception handling mechanisms, as discussed in Exception Safety With Symbian and Using Qt and Symbian C++ Together#Exceptions & Error Handling.
Further Information:
Signals & Slots
Signals and slots make it easy for objects of any kind to communicate with each other.
Signals are emited from objects when an event occurs - for example, a button or menu item is selected, or a timer expires. Developers can choose to connect a signal to any number of slots in any kind of objects; when a signal is emitted, all connected slots are called to handle the event.
Signals and slots are loosely coupled: an object which emits a signal neither knows nor cares which slot(s), if any, receive the signal. In addition the mechanism is type safe: the signature of a signal may have more arguments than the connected slot, but must otherwise match its signature (a slot may choose to ignore extra arguments).
Further Information:
User Interface Design and Development
Qt's standard GUI widgets and layouts make it easy to create rich GUI applications for the Symbian platform. The graphics view classes enable developers to draw and animate very complicated scenes containing thousands of objects, a task that would be very difficult using native methods.
Widgets & Layouts
Qt provides a rich set of standard user interface elements (known as widgets), including: buttons, progress bars, labels, combo boxes and frames, editors for text, numbers and dates, spin boxes, dials and even a calendar widget. Grouping elements include tool boxes, group boxes, tab widgets, and scrolling container widgets. Lists, trees, and tables are also available to present information stored locally, or as a view on information stored in databases. If the standard widgets aren't sufficient, there are libraries of commercially available and open source widgets that might suit your purposes. It's also straightforward to create custom widgets by sub-classing existing Qt widgets, or they can be designed from scratch.
Like Symbian UI controls, widgets can be containers of other widgets. However the drawing and ownership of sub widgets is much easier than for Symbian. Sub widget ownership is handled for you when you add a widget to a layout (or on construction, to a parent), and widgets are drawn when needed - there is no need to manually code a compound control hierarchy. In addition, the Signals & Slots make it very easy for widgets to notify the rest of the application of user input.
Layout managers allow developers to have precise control over the relative positioning and size of child widgets within a parent widget area. Layout managers automatically reposition and resize child widgets as necessary when the contents change - for example the window grows or shrinks, fonts change, widgets are hidden.
Layouts are very important on the Symbian platform. The showFullScreen() and showMaximized() methods resize the application window to fit the device, then the layout managers adjust the individual widgets to the available space (the difference between the methods is that showMaximized() leaves the softkey area at the bottom and the status area at the top clear, while showFullScreen() fills the whole screen). If the screen orientation changes, so will the window shape, resulting in a new layout being calculated. In many cases one layout can be used for all screen sizes in all orientations. Even if more layouts are required, these can be created with ease.
Further information:
Graphics Views
Qt's Graphics View Framework helps developers create, view and manipulate up to several thousand 2D graphical items. It provides a scene-oriented API for managing and interacting with a large number of items, and a view-oriented API for visualizing them. The API has support for features such as zooming and rotation, drag and drop, and animation of individual items. Developers can allow users to interact with individual items, or groups of items, in the scene.
It is possible to embed existing widgets directly into scenes with QGraphicsScene::addWidget() or create an instance of QGraphicsProxyWidget to embed the widget manually.
Developers may alternatively port widgets to the graphics view widget class: QGraphicsWidget. This provides the best of both worlds: most QWidget functionality like font, palette, layout direction, and geometry, with the addition of resolution independence and transformation.
| Note In future its expected that Qt will extend and evolve the Graphics View classes, so that they will be used for cases where we currently use QWidget. Qt's future declarative UI is based on Graphics View classes rather than traditional widgets. |
Further information:
Native & Custom Styles
Qt on the Symbian platform draws applications using QS60Style by default. This style simulates the Symbian platform's native look and feel and responds appropriately to device themes and theme changes. Applications can also use QWindowsStyle "out of the box", noting that this will ignore any device theme. The figures below shows a QS60Style being used with themes, and the same application in QWindowsStyle.
 Qt on Nokia 5800 (Default theme) |
 Qt on Nokia 5800 (Halloween theme) |
 Qt on Nokia 5800, Windows Style (No Theme) |
Application appearance can be customized in a number of ways. One of the simplest and most powerful methods is to use Qt Style Sheets. With a syntax similar to Cascading Style Sheets (CSS), this mechanism allows developers to change how widgets are drawn. Almost any aspect of drawing can be controlled, including shapes, margins, borders, line thickness and colour, fill gradients and colour, standard icons, and widget appearance in different states (e.g. pressed or not pressed, cursor hover/non-hover etc). Style sheets can be applied to whole applications, or they can be applied to groups of widgets or individual widgets.
The figures below show the "Candy Style" from C++ GUI Programming with Qt 4, Second Edition, Jasmin Blanchette and Mark Summerfield, Prentice Hall (2006) being applied to the default QS60Style. Note that the style sheet is obeyed exactly, ignoring any information from the theme.
 QS60Style with the "Candy" Style Sheet |
 QS60Style with the "Candy" Style Sheet (Halloween theme) |
 Menu - obeys the theme rather than any styling |
| Note Softkey and status areas are drawn by the underlying platform. It is not possible to apply Qt styling to these areas. |
Even more powerful control over application appearance can be achieved by sub-classing QStyle (or more likely, one of its derived classes e.g. QS60Style or QWindowsStyle); the main Qt platform styles are all created using this technique. However, since creating a complete style is a significant effort; it is more common for developers to use Qt Style sheets where possible.
Developers can also customize the colour schemes of individual applications and widgets by changing the palette used to draw individual elements. This relatively limited approach provides a similar level of customization to that available using the native Symbian C++ UI.
Cross platform "Mobile" APIs
The "Qt Mobility Project" has delivered a number of APIs that address common mobile use cases. The APIs are cross platform, and are hence also useful in Qt applications running on other mobile devices (e.g. netbooks) and desktop systems.
The APIs include:
- Bearer Management
- Contacts
- Location
- Messaging
- Multimedia
- Publish and Subscribe
- Service Framework
- System Information
For more information see Qt Mobility Project APIs.
Other Modules
Qt includes a number of other modules, not all of which are supported on the Symbian platform at this time. These modules provide features such as multi-threading, file handling,secure network communication, support for SQL databases, XML handling, application scripting, and a unit-testing framework. A selection of the modules are discussed below.
Networking
The Qt Network module provides classes to make network programming both straightforward and portable. Qt supports higher-level protocols such as HTTP and FTP and lower level socket classes for TCP and UDP communication. SSL is used to provide a secure network transport layer.
Symbian C++ developers will find that the higher level classes for HTTP and FTP handling are easier to use, by an order of magnitude, than the equivalent Symbian native classes. Some Symbian C++ functionality is not (at time of writing) available through Qt, for example HTTP filters.
Further Information:
SQL
The Qt SQL module provides a straightforward cross-platform API for integrating databases into Qt applications. Developers use SQL statements to manipulate databases, or C++ through the Qt database models. The database models can also be connected to "item view" widgets, making it very easy to present users with a view of data.
While Qt itself supports all the most commonly used SQL databases, only SQLite is available on the Symbian platform.
Further Information:
XML
Qt's QtXmlPatterns module provides high level classes for querying and manipulating XML data. The module supports XQuery 1.0 and XPath 2.0, for querying XML data and for querying non-XML data that can be modeled to look like XML. The XQuery/XPath language simplifies data searching and transformation tasks by eliminating the need for doing a lot of C++ or Java procedural programming for each new query task.
Qt also supports core XML functionality in the Qt XML module. This provides a stream reader and writer for XML documents and C++ implementations of SAX2 and DOM Level 2 parsers. The DOM API provides an interface for reading, writing, and in-memory manipulation of the content and structure of XML files.
The SAX2 parser provides an event-driven mechanism that feeds applications with document information as it reads each XML file - this is less suitable for manipulation of documents. SAX parsers are standards compliant, and hence this API is very similar to the XML parser provided in native Symbian C++.
Further Information:
Scripting
The QtScript module provides classes for scripting Qt applications, using ECMAScript (ECMAScript is the standardized scripting language on which JavaScript is based). Scripting allows applications to be extended at the point of installation, making easy to deploy bug fixes, or to create applications that users can extend themselves.
There are few limitations on what can be done using scripting, other than those imposed by the application programmer. Scripts can access objects, properties and functions that are exposed to them from C++, including graphical elements which may originally have been defined in UI Designer files. C++ signals can be connected to script based handlers (slots), or the script can create signal-slot connections, and even emit signals (although a script can't create a new signal).
While the Symbian platform already offers developers the ability to mix C++ with scripting languages, e.g. Python, the mechanisms provided by Qt are better integrated with C++, and mean that scripts can be used without the need for additional components to be installed.
| Tip Scripts are treated as "passive content" by Symbian's application signing program; changes delivered as scripts may be less costly to sign than those delivered as C++. |
Further Information:
WebKit Integration
The QtWebKit Module allows developers to merge the web into Qt applications, and Qt into web applications! This enables the creation of hybrid applications that would be difficult (if not impossible) in either of the environments on their own.
Web pages are trivially easy to embed in applications, and its not much more difficult to get information from a web service, transform it into a more useful format (using Qt's XML module), and then display it to the user. Developers can add local caching to their applications to improve responsiveness, and to enable off-line operation.
Qt widgets (and other C++ objects) can be embedded into Web pages, where their properties can be manipulated from JavaScript (in much the same way as described in the previous scripting section). This allows the possibility of "native" applications that can fetch a new appearance and functionality from a web server; and retain it in cache when off-line.
Further Information:
- Integrating Web Content with QtWebKit
- Qt Features for Hybrid Web/Native Application Development
- WebKit: Render, use and extend web technologies
Multimedia
Qt's high-level multimedia APIs are provided by the Phonon multimedia framework, an open source playback API originating from the KDE project. It provides functionality for playback of the most common multimedia formats, allowing media to be read from files or streamed over a network. Note that Phonon does not include any recording functionality; for that you will need to use lower level APIs.
| Note The Qt Labs Blog "Multimedia in Qt, what’s the story?" indicates that Phonon will eventually be replaced by new multimedia APIs, which at time of writing support playback, recording, radio, metadata and playlist management, and some experimental camera support. Phonon is expected to be supported for all Qt 4.x versions. |
The QtMultimedia module provides a Qt-style cross-platform API for low level access to audio and video devices. The API may be used directly within any application, but is most appropriate in situations requiring intermittent or lower latency playback. At time of writing QtMultimedia does not yet have a backend for the Symbian platform (this is planned for a patch release).
Internationalization
Qt provides the underlying infrastructure to support most of the world's languages, fonts, input techniques, character encodings and presentation conventions, and automatically uses the correct mechanisms for the current locale. Qt also provides tools to extract user-visible strings and their context from source code for translation, and the Qt Linguist GUI application to simplify the translation process.
The internationalization effort for application developers primarily consists of tagging user-visible literal strings in source code and providing enough context information for translators to be able to understand what each string is used for (using the tr() macro and other translation functions). Developers also need to write code to load and installs translation files on startup.
| Note Qt applications are easier to localize than Symbian C++ applications. The translation tools are more intuitive, and the fact that the first translation is provided at the point of use (and with a context) means that there is less scope for error. |
Further Information:
Licensing
Qt is available under a number of different licenses. Application developers working on the Symbian platform will usually select LPGL v2.1, which is largely compatible with the Eclipse Public License used by the Symbian Foundation.
Further Information:
Developer Tools
Qt comes with its own powerful development toolchain centered around the Qt Creator IDE (for developers) and Qt Linguist (for translators). Qt also provides IDE plugins that extend the popular Eclipse IDE with support for Qt - these are available by default in Carbide.c++, the Symbian platform's native IDE.
| Note Qt Creator is the recommended IDE for Qt application development on any platform. Carbide.c++ is more Symbian C++ aware; developers may find it more effective when debugging into Symbian C++ from Qt code. Note also that Carbide.c++ supports debugging on the Emulator, while Qt Creator supports debugging on phone hardware and on the Qt Simulator. |
Qt Creator IDE
Qt Creator is an intuitive and powerful cross-platform Qt IDE. It is available as a stand-alone package or in combination with the Qt libraries and development tools as a complete SDK.
Qt Creator includes:
- Advanced C++ code editor
- Integrated interface designer tool
- Project and build management tools
- Integrated, context-sensitive help system
- Visual debugger
- Code management and navigation tools
The Qt Creator Manual provides comprehensive documentation on how the IDE is used. The Qt Quick Start explains how to install Qt Creator 2.0.0 as part of the Nokia Qt SDK.
The IDE wraps a number of earlier tools (Qt Designer and Qt Assistant), which are discussed briefly below.
Qt Designer
Qt Designer is a graphical user interface design tool for creating Qt applications. While applications can be written entirely as source code; using Qt Designer can speed up development, and enables user interface designers to directly layout application menus, views and dialogs. Qt Designer is integrated into both Qt Creator and Carbide.c++.
Designing a user interface with Qt Designer is a simple process. Developers drag widgets from a toolbox onto a form, where they can be moved around, resized, copied, removed etc. Each widget’s properties can then be changed using the property editor (e.g. stylesheets, palettes, initial values).
Widgets can be positioned and sized with a defined geometry, or using layouts. Layouts allow components, and groups of components already in layouts, to be grouped and aligned either horizontally or vertically, optionally separated with spacers. This mechanism allows applications to resize appropriately for different device screen sizes and orientations.
Developers can create applications with menus, toolbars, balloon help and other standard features. Several form templates are supplied, and developers can create their own templates to ensure consistency across an application or family of applications. Programmers can create their own custom widgets that can easily be integrated with Qt Designer.
Qt Designer supports a form-based approach to application development. A form is represented by a user interface (.ui) file, which can either be converted into C++ and compiled into an application, or processed at run-time to produce dynamically-generated user interfaces.
Qt Designer eliminates the time-consuming “compile, link, and run” cycle for user interface design; its preview options let developers see how forms will behave in different platforms, without need to compile.
Qt Assistant
Qt Assistant is Qt's own powerful HTML help documentation system. It provides a browser like interface over the documentation set, and additionally uses a sophisticated indexing algorithm to provide fast full text searching.
It is available stand-alone and is pre-integrated with Qt Creator and Qt Designer.
Qt Linguist
Qt Linguist simplifies the translation of Qt applications.
Text needing translation is extracted from source code into translation source (.ts) files which may be edited in Qt Linquist, then compiled into binary Qt message (.qm) files that are loaded into applications at runtime. Qt Linguist also supports editing XML Localization Interchange File Format (XLIFF) files for interoperability with third party tools and services that support this format.
Qt Linguist displays both the string that needs to be translated, and context that helps the translator work out what the text is for. This context includes both the source code, and comments inserted by the programmer when the string was declared. For forms created using Qt Designer, the developer can also display any form with the current translation text inserted.
Translators are given intelligent guesses at possible translations based on previously translated strings and predefined translations. Guesses often serve as a good starting point, helping translators treat similar texts consistently. Common translations can also be stored in phrasebooks to make the translation of future applications more efficient.
Qt Linguist’s comprehensive manual provides relevant information about the translation process for release managers, translators and programmers.
Carbide.c++ IDE
Carbide.c++ is the Symbian platform's native C++ development IDE. Carbide.c++ pre-integrates Qt's Eclipse IDE plugin, adding:
- A fully integrated form editor with layout support (Qt Designer).
- Wizards for creating new Qt application, dialog and widget projects.
- Automated build setup for Qt-specific build steps.
- Integrated Qt documentation.
The Qt/Carbide.c++ toolchain abstracts almost all Symbian-platform specific aspects from the developers for a "basic" project. Carbide.c++ automatically creates the files needed by the standard Symbian C++ build and packaging toolchain from the Qt project (.PRO) file (bld.inf, abld.bat, other make files, resource files (.rss), and Package files (.pkg) are all effectively temporary files).
Developers retain all the benefit of working with Carbide.c++ on the Symbian platform, including the ability to debug on-target, and to have an IDE that is Symbian C++ aware when debugging from Qt in to Symbian C++ code. They also benefit from other tracing and analysis tools that are integrated into the IDE.
For information on using Carbide.c++ with Qt on the Symbian platform, see the Qt Carbide.c++ IDE Quick Start.
Smart Installer
To help with deployment on devices where Qt is not part of the platform, developers can deploy a "Smart Installer" alongside an application inside a SIS package. When a package is downloaded onto a device, this small utility makes sure that all the Qt dependencies for the application are also installed.
If the installer needs to obtain missing libraries or upgrade existing ones, it will obtain the user's permission before downloading them via the user's preferred network connection.
Qt developers can use familiar tools to create the signed SIS file containing the Smart Installer. The process is the same as for the creation of an ordinary SIS file.
What's Coming
The following projects do not deliver in Qt 4.6, but are of significant interest to Qt developers targeting the Symbian platform.
New APIs
There are new Qt APIs coming out of the Qt Mobility Project in addition to those provided in the Qt Mobility Project v1.0.0 release.
UI Extensions for Mobile (Orbit)
The UI Extensions for Mobile (uiemo) deliver a powerful and intuitive Qt-based user interface, optimised for mobile platforms. The uiemo libraries are expected to replace the Symbian platform's existing (Avkon) UI in Symbian^4 timeframes.
At high level, the uiemo extension libraries provide:
- A scalable UI implementation based on QGraphicsView, including a UI widget library optimized for mobile user experience
- An input framework to handle various hardware and onscreen input methods
- A control & feedback framework, including integration to tactile feedback and gesture support
- Extensions for internationalization and localization
More information, and a snapshot of the current state of development, is available here on Mercurial and here on Gitorious.
| Note The proposal to replace the Symbian platform UI with UIEMO were originally discussed in the topics: Direct UI and Orbit |
Qt Quick
Coming in Qt 4.7 and Qt Creator 2.0 releases is Qt Quick (Qt User Interface Creation Kit). This is a high-level UI technology that allows developers and UI designers to work together to create animated, touch-enabled UIs and lightweight applications without needing C++! The technology is based around a declarative language called QML (that looks a lot like CSS) and a new graphical editor in the Qt Creator IDE.
Community, Documentation & Source
Qt developers benefit from an active community with hundreds of thousands of members, providing hints, tips and examples that are equally applicable to Qt on the Symbian platform.
The Qt Development Frameworks website (http://qt.nokia.com) maintains a centralized list of community resources, including 3rd party communities, websites and forums, web 2.0-style social networking services, mobile communities and wikis: http://qt.nokia.com/developer/community-resources. The site also provides access to a number of mailing lists (http://lists.trolltech.com/) and a newsletter (Qt Quarterly).
Qt’s extensive documentation is available on-line at: http://doc.qt.nokia.com. Developers that are targeting the Symbian platform may prefer to use the Qt 4.6 snapshot: http://qt.nokia.com/doc/4.6. There are also a number of Qt programming books, some of which have been translated into a number of languages: http://qt.nokia.com/developer/books.
Qt Labs (http://labs.qt.nokia.com/) is where developers working on Qt publish information about projects, new ideas, and components in order to get feedback; this is a great place to see what's going on, and join in the fun!
Qt Development Frameworks and its partners provide a range of training options for Qt, including open enrollment courses for the general public and on-site courses for customers who have more specific training needs. See http://qt.nokia.com/developer/training for information on training, and http://qt.nokia.com/developer/learning for general information related to learning and certification paths.
Developers that are particularly interested in issues related to Qt on the Symbian platform port may wish to become part of the Symbian Foundation Qt Developer Community.
We'd appreciate feedback about Qt on the Symbian platform through the qts60-feedback-request mailing list (mailto:qts60-feedback-request@trolltech.com to join), or the Qt Bug Tracker. As Qt source code is all hosted on a public Gitorious repository (http://qt.gitorious.org/qt/qt) developers can even submit solutions directly.
Summary
The article has discussed some of the Qt functionality of most interest to mobile developers, the Qt developer tools, and the vibrant developer community. It has also provided a sneak preview of some of the the functionality we can look forward to arriving in the not-too-distant future.
Qt exposes intuitive and high level APIs that address the needs of most developers. The signals and slots mechanism makes it easy to to connect user actions to application logic, and indeed any objects to arbitrary other objects. Most C++ memory management issues are handled by Qt, leaving application developers to focus on application structure and behaviour. Qt applications follow the native look and feel of the platform. However designers can radically modify the appearance of a user interface, from a single widget to a complete application, using style sheets or custom styles.
Qt is well documented. Thorough documentation and code examples provide everything you need to get started developing using Qt.
Programming with Qt is easier than with Symbian C++, and enables the development of powerful applications that would be difficult (at best) to create with native APIs. Symbian C++ developers usually find it easy to migrate to Qt, and can often create more complicated applications more quickly, with only a few months exposure. Developers that want to know more should visit http://qt.nokia.com/products/whats-new-in-qt.
 | © 2009 Nokia Corporation and/or its subsidiary(-ies). This document is licensed under the Creative Commons Attribution-Share Alike 2.5 license. See http://creativecommons.org/licenses/by-sa/2.5/legalcode for the full terms of the license. |
Comments
Sign in to comment…
