Overview of the GNOME Platform

You should read this document if you want to create software using the GNOME platform. Developing with the GNOME platform will help you create consistent applications that integrate well into the user's desktop. This guide will introduce you to the various components of the platform, so you know which libraries can accomplish which tasks. This guide links to additional detailed documentation, so you can explore each component of the platform in more depth.

This guide will also be useful if you are picking a development platform for your software project. It will provide an overview how you can use the GNOME platform to build useful software.

This guide also describes ways of extending the GNOME desktop with plugins, panel applets, and other useful tools. If you want to develop additional functionality to plug into the GNOME desktop, you should read this guide, particularly Chapter 5, Desktop Technologies.

If you have existing software that you want to port to the GNOME platform, you should see the online Guide For ISVs in addition to this guide.

GNOME is a global effort, with many contributors all over the world. GNOME is a success because of its contributors and users. This section lists the web sites and conferences where you can learn more about GNOME, as well as other organizations that work with GNOME.

GNOME provides a number of libraries for constructing attractive graphical interfaces. It provides libraries for displaying and controlling common user interface controls, for layout out and rendering text from any of the world's writing systems, and for drawing sophisticated vector graphics to the screen. The graphical technologies in GNOME are outlined in the section called “Graphical Interfaces”.

The GnomeVFS library provides a file system abstraction that allows users to work with files on remote server as well as the local file system. Using GnomeVFS for file and folder operations allows your application to support remote folders automatically. GnomeVFS is discussed in the section called “Virtual File System”.

GNOME provides the GConf library and daemon for storing and retrieving user preferences. GConf has a simple API that makes it easy to provide instant-apply preferences in your application. Using GConf also allows administrators to provide default and mandatory application settings for their users. GConf is discussed in the section called “Configuration and Lockdown”.

GNOME provides facilities for internationalization and accessibility, helping you reach the largest possible number of potential users. Much of the internationalization and accessibility support is built right in, but there are many issues you should be aware of when developing applications. Internationalization is discussed in the section called “Internationalization”. Accessibility is discussed in the section called “Accessibility”.

GNOME ships with the GStreamer multimedia framework, and extremely powerful framework for creating, editing, and playing audio and video content. GStreamer is discussed in ???.

GNOME also provides a complete print framework which leverages CUPS whenever possible. The print framework in GNOME allows you to provide a consistent interface to high-quality printing. The print framework is discussed in the section called “Printing”.

The GNOME desktop has full support for transferring data using the clipboard or with drag and drop. The APIs in GTK+ can help you create applications that interoperate well with the rest of the desktop. Clipboard and drag and drop functionality are discussed in the section called “Clipboards and Drag and Drop”.

With freedesktop.org, GNOME provides the D-Bus messaging system. D-Bus is a cross-desktop message bus which allows all types of applications to communicate with one another. D-Bus is discussed in the section called “D-BUS Messaging”.

GNOME features the Bonobo component system, built on top of CORBA. Bonobo allows programmers to create complex embeddable components which can be reused inside other programs. Bonobo is discussed in the section called “Bonobo and CORBA”.

To make networks more manageable for users, GNOME supports DNS Service Discovery. DNS Service Discovery enables applications to find services automatically on a local network, rather than requiring users to provide network addresses. DNS Service Discovery is discussed in the section called “Service Discovery”.

Finally, GNOME provides a number of libraries for working with XML and web services. These technologies are becoming increasingly important to application developers. XML and web services are discussed in the section called “XML and Web Services”.

The GNOME desktop features numerous places where applications can provide better integratation, such as providing panel applets or plugins for the file manager. Many of these features are discussed in Chapter 5, Desktop Technologies.

GNOME provides comprehensive Human Interface Guidelines to help you create more usable applications. GNOME's usability standards were a first among free desktop environments, and they continue to improve through GNOME's commitment to a better user experience. Usability is discussed in the section called “Usability”.

GNOME also provides a complete help system, as well as style guidelines for writing documentation. Though often under-appreciated, good user help can significantly improve your software. Documentation is discussed in the section called “Documentation”.

Most applications will need to provide a graphical interface to interact with users. Graphical interfaces can create an intuitive and discoverable medium for people to interact with software, and users expect applications to provide usable and attractive user interfaces.

The GNOME Platform features sophisticated graphics and user interface technology, from standard user interface controls to an API for drawing high-quality graphics to the screen. Using the graphics technologies in GNOME allows you to create applications that are consistent, intuitive, and aesthetically pleasing.

Figure 3.1. Layered Look at Graphics Libraries

Pango

Pango is the core text and font handling library in the GNOME platform. It is responsible for laying out and rendering text, and is used throughout GTK+.^[1]

Pango has extensive support for the various writing systems used throughout the world. Many of the writing systems used for languages have complex rules for layout out glyphs and composing characters. With Pango, nearly all languages can be written and displayed correctly, allowing users everywhere to view text in their native languages. Pango support for multiple writing systems is automatic; application developers do not have to write any special code to support other languages.

Figure 3.2. Displaying Multiple Languages With Pango

[D]

Pango supports the text styling used in typical documents and interfaces, including italics, font weights, and underlines. Pango uses a simple XML-like vocabulary called PangoMarkup which enables you to set font size, color, styles, and other text attributes. Using PangoMarkup, you can specify inline styles without manually iterating over text blocks. PangoMarkup can be used directly from GTK+, enabling you to style text in your graphical interfaces easily.

You should use Pango directly whenever you need to lay text out on the screen or on a different medium. Using Pango will allow your text layout to work seamlessly with GTK+ and the rest of the GNOME platform. It will help you create portable code, and most importantly, it will ensure that your application can render text correctly in hundreds of different languages.

For more information on Pango, see The Pango Reference Manual.

GnomeVFS is the core library used for all file and folder operations in GNOME applications. GnomeVFS provides a file system abstraction with pluggable backends, allowing you to use a single consistent API to access files on the local file system, on FTP servers, on WebDAV servers, and over various other protocols and transports.

All resources, including local files, are accessed in GnomeVFS using Uniform Resource Identifiers (URIs). An extension to the now-commonplace URL, this standard identification scheme allows all resources to be addressed with a simple and consistent syntax.

GnomeVFS can provide extensive information about files and folders, including the MIME type of the file and which applications can be used to open the file. Since GnomeVFS uses the standard from freedesktop.org to determine file types and file associations, it works correctly on different free desktop environments, helping independent software developers create software that can be run in different environments.

GnomeVFS also provides basic networking support, including routines for network I/O, secure transfers with SSL, and DNS Service Discovery.

GnomeVFS is used extensively throughout the GNOME desktop. The file manager, Nautilus, uses GnomeVFS to display folders on local and remote systems. For the user, this means that network servers act just like local folders: They can drag and drop files between them, view the files' properties, and open the files with an application. Using GnomeVFS will allow your application to open all the files that users can access on their desktops.

For more information on GnomeVFS, see GnomeVFS - File system Abstraction Library.

GConf is the system for storing and retrieving configuration settings in GNOME. GConf consists of two parts: a client library for accessing settings, and a session daemon which is responsible for the details of storing and retrieving those settings. Using a daemon allows GConf to use different storage backends, validate input, and provide simultaneous access to different applications.

Settings stored in GConf are stored and retrieved using a unique key, or identifier string. Keys use a simple hierarchical namespace to avoid collision among settings for applications and the desktop. You can provide a schema file to detail your configuration keys. This allows GConf to validate the type of the input, and to show localized documentation about the key. This helps systems administrators, who can set multiple settings at once without having to navigate preference dialogs.

GConf can look up settings from different settings at once, typically from different locations on the file system. By having appropriate system sources configured, GConf enables systems administrators to provide both default and mandatory settings for all users. Tools such as GNOME's Configuration Editor and Sabayon make it easy to deploy fully configured systems using GConf.

The GConf client library provides notifications of changes to settings, making it easy to provide instant-apply settings in your application, regardless if settings are changed from within your application or using another tool. Setting the value of a key will notify all interested applications, allowing desktop-wide and other cross-application settings to work instantly and effortlessly.

GConf makes it easy to lock down systems by setting particular keys read-only, preventing users from changing their values. In addition, GNOME provides a number of high-level keys that can be used to disable actions such as saving to disk and changing the panel layout. Tools such as Pessulus make it easy for administrators to find and lock down important keys.

You should use GConf to store all user preferences in your application. Using GConf will make it easy to provide instant-apply preferences, and it will make your settings accessible to systems administrators and configuration and backup tools.

For more information on GConf, see The GConf Reference Manual.

The GNOME Desktop and Developer Platform provides full support for internationalizing and localizing applications. Internationalization is the process of ensuring your application can be localized, including marking all strings for translations, using numbers and format strings correctly, and making adjustments for variations in conventions for times and dates, units, and formatting.

GNOME uses the standard gettext and related routines for accessing localizations. Support for localization using gettext is built into every component of the GNOME platform. Your source code can be scanned for specially-marked tools by automated tools. Those strings are then placed in PO files to allow translators to track their translations. Using gettext, you can easily and efficiently access translated versions of all user-visible strings in your application from translation domains installed along with your application.

These translation domains can be created using PO files, which can be used by translators to track string changes and update their translations accordingly. GNOME ships with intltool, a tool for managing translations in PO files. Using intltool, translators can use PO files to translate not only the strings in your application, but also other types of files that you use, such as GConf schema files, desktop entry files, and XML files.

GNOME also provides the xml2po tool as part of the gnome-doc-utils package. This tool allows translators to use PO files to create translated versions of documentation written in various XML formats, including XHTML and DocBook.

Internationalization involves more than just allowing strings to be translated, and GNOME supports your application development at every step of the process. GTK+ will automatically adjust its presentation for languages that are read right-to-left, and Pango has complete support for rendering bidirectional text and text in various different writing systems. GTK+ supports multiple input methods, allowing users from all language to input text efficiently with their keyboards. The entire GNOME platform uses the UTF-8 encoding of Unicode natively, providing access to the characters and writing systems of the entire world.

Figure 3.3. Gnumeric in Multiple Languages

[D]

Internationalizing your application helps make it available to many more users across the world. While skilled translators must provide translations for any language, programmers must ensure the application is properly internationalized before it can be fully localized.

For more information on internationalization in GNOME, see Internationalizing GNOME Applications.

Accessibility is the process of ensuring your application can be used by people with various disabilities. Disabilities come in many forms: visual impairments, movement impairments, hearing impairments, cognitive and language impairments, and seizure disorders. Many people have some sort of disability, and making your application accessibility will allow everybody people to user your application effectively.

GNOME provides support for accessibility devices using the ATK framework. This framework defines a set of interfaces to which graphical interface components adhere. This allows, for instance, screen readers to read the text of an interface and interact with its controls. ATK support is built into GTK+ and the rest of the GNOME platform using the GAIL library, so any application using GTK+ will have reasonable accessibility support for free.

Nonetheless, you should be aware of accessibility issues when when developing your applications. Although GTK+ interfaces provide reasonable accessibility by default, you can often improve how well your program behaves with accessibility tools by providing additional information to ATK. If you develop custom widgets, you should ensure that they expose their properties to ATK. You should also avoid using sound, graphics, or color as the sole means of conveying information to the user.

For extensive recommendations on accessibility, see GNOME Accessibility for Developers. See also ATK - Accessibility Toolkit and The GAIL Reference Manual.

GStreamer is a powerful multimedia library for playing, creating, and manipulating sound, video, and other media. You can use GStreamer to provide sound and video playback, record input from multiple sources, and edit multimedia content. GStreamer supports encoding and decoding numerous formats by default, and support for additional formats can be added with plug-ins.

GStreamer provides a flexible architecture wherein media is processed through a pipeline of elements. Each element may apply filters to the content, such as encoding or decoding, combining multiple sources, or transforming the multimedia content. This architecture allows for an arbitrary arrangement of elements, so that you can accomplish virtually any effect using GStreamer. Furthermore, GStreamer is designed to have low overhead, so it can be used in applications with high demands on latency.

While GStreamer provides a powerful API for manipulating multimedia, it also provides convenient routines for simple playback. GStreamer can automatically construct a pipeline to read and playback files in any supported format, allowing you to use sound and video in your application easily.

You should use GStreamer whenever you need to read or play multimedia content in your application, or if your application needs to manipulate sound or video. Using GStreamer makes your application development easy, and it provides you well-tested elements for many of your needs.

For comprehensive information on GStreamer, see The GStreamer Application Development Manual, The GStreamer 0.10 Core Reference Manual, and the GStreamer documentation page.

Many applications need to provide support for printing, including word processors, spreadsheets, image programs, and specialized data viewers. Users often expect to be able to print the contents they can view on-screen. The GNOME Platform provides libraries to help you add support for high-quality printing to your application.

As users work with more and more types of data in different applications, they have an increasing need to share objects and data between their applications. GNOME supports two related methods for transfering data between applications: using drag and drop operations, and copying to and pasting from a system-wide clipboard. Both the clipboard and drag and drop work across multiple applications, including those not developed with GNOME.

The clipboard is used when a user explicitly copies data in an application. The application then claims ownership of the clipboard. When the user pastes the data into another application, that application requests the clipboard data from the first application. Clipboard operations are fully supported in GTK+.

Drag and drop operations are similar, but they require the pointer to be tracked and updated as the user moves across potential drop targets. When an application is notified a pointer is moving over it during an active drag, it must update the cursor to indicate whether or not it can accept the drop. GTK+ provides drag and drop support with a sophisticated API that makes it easy to manage drop targets in your applications.

Both the clipboard and drag and drop operations support content negotation. When an application has data to offer, it advertises which formats are available for that data. Receiving applications can request the most suitable formats. For instance, if a user copies text from a web browser, a word processor can maintain formatting by requesting the data in HTML, while a plain text editor can receive the text without formatting.

You should provide clipboard and drop and drop functionality for any data your application operates on. The clipboard and drag and drop are useful for more than just text: files, graphics, and sound clips are all examples of data that can be transferred between applications. When you use GTK+, you automatically get clipboard and drop and drop support for text areas, color buttons, file choosers, and other built-in user interface controls. You should use the APIs in GTK+ to provide support for any other data in your application.

For more information, see Drag-and-Drop Protocol for the X Window System, X Clipboard Explanation, and The Clipboard Manager Specification.

D-Bus is a cross-desktop message bugs for sending events between various applications, the desktop, and low-level components of the system. D-Bus provides a simple API for sending messages to particular services and for broadcasting messages to all interested services. D-Bus enables different types of applications to communicate and integrate with each other and with the desktop, providing better interaction and a richer experience for the user.

D-Bus provides a session and a system bus. The session bus is used by applications in a single user session, allowing them to share data and event notifications and to integrate into the user's desktop. For example, movie players can send a D-Bus message to prevent the screensaver from activating when the user is watching a movie.

The system bus is a single message bus which runs independently of any user sessions. It can communicate with applications in any session, enabling those applications to interact with system components without dealing with low-level system details. The system bus is used to provide important functionality that users expect to work on their systems. For example, the system bus is used to monitor when network interfaces go up or down, when external drives get plugged in, and when laptop batteries are low.

D-Bus is developed jointly on freedesktop.org, so you can use it with different desktop environments and applications. Because D-Bus is a cross-desktop project, you use it to create portable and versatile software that seamlessly integrates with the user's desktop, regardless of which desktop it is.

For more information on D-Bus, see The D-BUS Tutorial and The D-BUS Specification.

Bonobo is a framework for creating reusable components for use in applications. Built on top of the industry-standard Common Object Request Broker Architecture (CORBA), Bonobo provides the all the common interfaces needed to create and use well-behaved components in GNOME applications.

Bonobo components can be used in a variety of situations, and can help create flexible and extensible software. For example, a component to display multimedia content could be embedded inside a word processor, effectively adding multimedia support to the word processor without the word processor working directly with it. Bonobo components are also used to embed the applets in the GNOME panel. Using Bonobo enables the applets to communicate effectively with the panel, affording users a consistent interface.

Bonobo components are not limited to graphical controls. Bonobo is used by Evolution, GNOME's email and groupware suite, to provide access to users' addressbook and calendar. This allows users to keep all their information in one place, where all applications can access it.

Bonobo is built off of CORBA, allowing components to run in seperate processes. Components can be written in different languages and run on top of different runtimes; they need only adhere to an interface specified with the Interface Definition Language (IDL). CORBA's flexible design even allows components to run on seperate machines over a network.

GNOME provides its own fast and lightweight CORBA implementation with ORBit. The tools and libraries supplied with GNOME even allow components to be written effectively in C, a language often excluded by other CORBA implementations. ORBit is an incredibly fast CORBA implementation.

Bonobo helps fill the gaps in CORBA, providing the additional interfaces and specifications needed to support consistent components. Although you will rarely need to use CORBA without Bonobo, it can be used directly. For instance, GNOME's accessibility infastructure uses CORBA to allow assistive tools to inspect and interact with running applications.

You may wish to use Bonobo to provide complex graphical components that can be embedded into applications. For most IPC needs, however, GNOME is moving towards D-Bus, as integrating D-Bus into applications is considerably easier.

For more information on Bonobo, see The Libbonobo Reference Manual and The LibbonoboUI Reference Manual. For information on ORBit, GNOME's CORBA implementation, see The ORBit2 Reference Manual.

DNS Service Discovery, or Zeroconf, is a technology for automatically locating available services on a network. Zeroconf allows users to access network resources without having to provide explicit addresses or configure their applications manually.

DNS Service Discovery is already used in numerous places throughout GNOME, and further support will be added in the future. For example, Nautilus, the GNOME file manager, uses DNS Service Discovery to locate various file servers on the local network. Ekiga, the videoconferencing and telephony application in GNOME, can locate can publish the user's presence and locate other users on a local network using DNS Service Discovery.

Full DNS Service Discovery support is provided by the Avahi library. For more information on Avahi, visit the Avahi web site. GNOME also provides limited support for locating services in GnomeVFS. For more information, see Zeroconf networking support.

In our increasingly inter-connected world, more and more applications need to provide support for various web services. Sometimes web services simply provide added functionality, while other times they are the core purpose of the application. Even applications that have been providing a standalone user experience for years have found innovative new uses for web services.

The GNOME Platform provides support for using web services from within your application, as well as comprehensive libraries for consuming, managing, and transforming XML, the language of the web.

In order for applications to be useful, users need to be able to find and open them. Users of the GNOME desktop may open applications using the applications menu, or they may open them by accessing files in the file manager. The GNOME desktop allows you to add applications and file types when you install your application. The mechanism for these is specified on freedesktop.org, so the same data will allow your application to function in other desktop environments.

Adding your application is as simple as providing a desktop entry file with the necessary information. Desktop entry files use a simple key-value syntax, with extra provisions for providing translated content of particular values. Your application's desktop entry file will contain the following information:

If your application handles custom file types that are not already known by the system, you will need to add those types to the file type registry. All file types are accessed with MIME types. For example, Ogg Vorbis audio files have the MIME type application/ogg. To add a MIME type, you need to provide a description of the type using a MIME information XML file. These files provide a translated name for the type as well as information on how to determine which files are of the type, either by matching the file name or by inspecting the contents of the file.

For more information on applications, see The Desktop Entry Specification and The Desktop Menu Specification. For more information on file types, see The Share MIME Info Specification.

The GNOME desktop features flexible and powerful panels to which users can add any number of small applications, called panel applets. Panel applets can provide all sorts of quick access to all sorts of useful information and functionality. For instance, the GNOME desktop ships with panel applets to switch between windows and workspaces, display the current weather conditions, and display network activity, among many others.

You may provide a panel applet to augment the functionality of your application, or you may provide a simple stand-alone panel applet. If you simply need to display quick notifications, you should consider using the notification area instead, which is also displayed in the user's panel. Panel applets should be used when you need to provide more functionality than that provided by notification icons.

Panel applets are independent processes that use Bonobo to communicate with the panel. Bonobo allows applets to integrate with the panel to provide a consistent user experience. For example, the context menu for every panel applet contains standard items to remove, move, and lock the applet. Each panel applet can then add items to the context menu to perform other actions. The Weather Report panel applet, for example, has context menu items to display a detailed report and to update the displayed information.

For more information on panel applets, see The Panel Applet Library.

In addition to launchers and panel applets, the GNOME panel also features a notification area that applications can use to notify users of events. Notifications can be used to alert the user to new email, available updates, upcoming meetings, or any number of other events.

Notifications are simple icons that your application can place in the notification area on the user's panel. Your application can then take further action when the user clicks on the icon. Currently, the notification system is implemented in the experimental Egg library; however, the next version of GTK+ will have support for notification icons.

The notification area is a freedesktop.org specification, so your notification icons will appear in other desktop environments as well. For more information on the notification area, see The System Tray Protocol Specification.

GNOME ships with Nautilus, an intuitive and powerful file manager. Using the advanced GnomeVFS technology, Nautilus is able to display remote folders just like folders on the local file system, giving users access to all their files everywhere with a single consistent interface.

Nautilus provides a plugin interface, enabling developers to extend its functionality to provide more information about users' files. This provides a richer and more coherant experience for users, removing the need for seperate applications to manage various types of files.

Nautilus plugins can extend the file manager's functionality in a number of ways. Plugins can add extra information to file properties dialogs, providing users with everything they need to know about files. For example, GNOME ships with a plugin to display extra information about audio and video files, such as the codec used, the dimensions of the video, and artist and album of music files extracted from a CD.

Plugins can also add columns to the list view and automatically place emblems on files. This can be used to provide pertinent information to the user at a glance. For example, a Nautilus plugin could provide version control information on folders checked out from a version control system. Users could see directly in the file manager if a file is up to date, or if changes have been made locally.

Nautilus also allows developers to add items to the context menu for files and folders. Context menu items can specify for which types of files they should be displayed, so the context menu only provides actions that are relevent for the selected files. For example, File Roller, GNOME's archive file utility, adds an item to the context menu to extract archive files directly. Extra context menu items provide easy access to common operations on different types of files.

In addition to a flexible plugin architecture, Nautilus can also display a thumbnail for any type of file for which a thumbnailer has been provided. Thumbnails show a preview of the file, helping users find the files they want. GNOME can automatically create thumbnails for most image and movie files, and allows applications to install additional thumbnailer programs to create thumbnails for application-specific files. Thumbnail management is fully specified by freedesktop.org, so any thumbnailers you provide can be used by all applications.

The window manager is a special program responsible for drawing the borders and titlebars around windows. The window manager is responsible for handling all the operations performed on windows, such as moving, resizing, minimizing, and moving between workspaces. Windows are managed consistently with little or no work from application developers.

External programs can, however, interact directly with the window manager, and even control its behavior. Using GNOME's libwnck library, applications can get information about the placement and state of all the windows and instruct the window manager to perform various actions on those windows.

Window manager interaction with libwnck can be used for simple tasks, such as displaying workspace and window list applets on the user's panel, as well as for complex applications, such as performing automatic actions on new windows based on certain window properties.

The GNOME desktop provides a single menu of all the desktop-wide preferences and system administration settings. Preferences and settings dialogs can be placed in this menu to make them easily accessible. Dialogs can be placed in the preferences menu by adding them to the applications registry with the Setting category. Dialogs can be placed in the administraion menu using both the Settings and System categories.

If you provide a dialog that allows administrators to configure desktop systems, then you should add your dialog to the administration menu. If you provide a dialog that allows users to adjust preferences that affect a number of applications, then you should add your dialog to the preferences menu. You should not use these global menus for individual application preferences.

GNOME provides a modern a secure keyring manager to store users' passwords and other sensitive data. Applications can use the keyring manager library to store and access passwords, and users can manage their passwords using GNOME's Keyring Manager application.

The keyring manager provides any number of keyrings, where each keyring can contain any number of keyring items. Items in a keyring store some piece of data, often a password. Each keyring is locked individually, and users must provide a password to unlock the keyring. Once a keyring has been unlocked, the user has access to all of the items in that keyring.

The keyring manager provides access control lists for each keyring item, controlling with applications are allowed access to that item. If an unknown application attempts to access a keyring item, the keyring manager will prompt the user to allow or deny that application access. This helps prevent malicious or poorly-written programs from accessing the user's sensitive data.

Keyring data stored on the file system is encrypted with the AES block cipher, and SHA1 is used for hashes of the item's attributes. Using the attributes hash, the keyring manager is able to look up items requested by applications without ever unlocking the keyring. The keyring has to be unlocked when a matching item is found and accessed.

The keyring manager also provides a session keyring. Items in the session keyring are never stored on disk, and are lost as soon as the user's session ends. The session keyring can be used to store passwords to be used in the current session only.

If you use GnomeVFS to access remote servers, you automatically get the benefits of the keyring manager. Whenever GnomeVFS needs to authenticate the user, it provides the option to store the password, either in the default keyring or in the session keyring.

You should use the keyring manager whenever your application needs to store passwords or other sensitive data for users. Using the keyring manager provides a better user experience while still keeping user data safe and secure.

GNOME provides tools to allow your application to run smoothly from session to session. Users can log out with running applications and have those applications fully restored when they log back in. To provide this functionality, your application must connect to the session manager and save its state when the user logs out.

GNOME provides a simple API for session management in the GNOME User Interface Library. See the section GnomeClient of The GNOME UI Library Reference Manual for more information on working with the GNOME session manager.

With Evolution Data Server, GNOME provides a single address book and calendar that all applications can use to store and retrieve information. Using Evolution Data Server means that users no longer have to maintain separate lists of contacts in each application, or manually copy events to their calendar.

People use computers increasingly to interact with their friends and colleagues. Applications such as email programs, instant messengers, and telephony and video conferencing applications are used to communicate with others. These applications often provide contact lists to help users. Using Evolution Data Server, applications can store contact information in a single location, allowing all applications to see all the pertinent data about users' contacts.

Applications can also use Evolution Data Server to store and retrieve appointments on the user's calendar. For example, the clock on the panel shows a simple calendar when clicked. If the user has any appointments scheduled, they are shown alongside the calendar. This makes it easy to see upcoming appointments without opening a full calendar application.

For more information on the address book, see Evolution API Reference: libebook. For more information on the calendar, see Evolution API Reference: libecal.

The GNOME desktop is designed around usability, and it aims to provide a consistent and simple user experience. People use computers to get work done (or to play!), not to figure out complicated user interface puzzles. When designing your application, you should consider how well users can recognize common user interface paradigms, how quickly they can learn the elements that are unique to your application, and how efficiently they can execute tasks once they've learned them.

GNOME provides comprehensive Human Interface Guidelines to help you write applications that are attractive and usable. While no guidelines can provide a single answer for all usability concerns, understanding the GNOME Human Interface Guidelines can make it easier to create a usable application. For more information, please see The GNOME Human Interface Guidelines.

All applications should provide documentation to help their users understand the application and troubleshoot problems that may arise. While a well-designed application should not require reading the documentation before use, documentation can nonetheless be an important tools for users, particularly for complex applications.

GNOME provides a unified framework for providing user documentation. You can provide documentation in the industry-standard DocBook format. Using DocBook means that you don't have to worry about formatting details. Instead, your documentation will be automatically formatted with the same consistent conventions as the rest of the system documentation.

GNOME's help viewer, Yelp, displays and print documentation, provides a listing of all documentation on the system, and allows the user to search the full text of all documentation. Using the GNOME help system gives you all these features for free.

For more information on writing documentation for your application, see The GNOME Handbook of Writing Software Documentation, DocBook: The Definitive Guide, and The GNOME Documentation Style Guide.

The C++ bindings provide complete coverage of the GNOME platform, including GTK+, Glade, and GConf. The C++ bindings wrap all objects with native C++ objects and allow programmers to provide custom widgets with normal C++ inheritence. They provide a fully native API, with type-safe signal handlers, full use of the standard C++ library, and complete C++ memory management.

For more information on the GNOME C++ bindings, visit the gtkmm web site.

The Java bindings provide complete coverage of the GNOME platform, including GTK+, Cairo, and GConf. The Java bindings wrap all objects with native Java objects and allow programmers to provide custom widgets with normal Java inheritence. They provide a fully native API, using Java's class libraries and interfaces wherever appropriate.

For more information on the GNOME Java bindings, visit the Java-GNOME web site.

The Perl bindings provide native Perl interfaces for the GNOME platform, including GTK+, GnomeVFS, and GConf. The Perl bindings wrap all objects with Perl objects and allow programmers to use standard Perl practices to manipulate them. They provide a fully native API, using Perl's native data types wherever appropriate.

For more information on the GNOME Perl bindings, visit the gtk2-perl web site.

The Python bindings provide native Python interfaces for the GNOME platform, including GTK+, GnomeVFS, and GConf. The Python bindings wrap all objects with native Python objects and allow programmers to provide custom widgets with normal Python inheritence. They provide a fully native Python API which automatically handles details like type casting and memory management.

For more information on the GNOME Python bindings, visit the PyGTK web site.

Full or partial bindings exist for many other programming langauges, such as C#, Eiffel, JavaScript, Ruby, and Scheme. Even though they may not currently be officially supported by GNOME, many of these bindings are of the same high quality as the official GNOME bindings, and some of them may be included as official GNOME bindings in future releases.

For a list of language bindings, visit the GTK+ bindings page.