Talks, Papers, and Articles

Over the last year, a large amount of work has been done on GNOME Shell, the key new component of the GNOME 3 user experience. Major changes have been made to the user interface, new features have been added, and it has generally progressed rapidly toward being a compelling choice for everyday use.

This talk will describe the work done in the last year, including a tour of new features and user interface changes. It will discuss how GNOME Shell fits in with the rest of GNOME 3, remaining work needing to be done for GNOME 3 on GNOME Shell itself and in integration with other components, and provide a look at how development on GNOME Shell is expected to proceed beyond the initial GNOME 3 release.

The GNOME Shell is a major component proposed for GNOME 3.0. It takes over the window management and application launching roles and provides an intuitive unified experience as the user navigates between tasks and documents.

The shell is built on several technologies new to GNOME: the desktop is displayed as an OpenGL scene graph using the Clutter library. It is primary coded in Javascript, and access to the GNOME platform and to low level code written in C is done using gobject-introspection, which eliminates the need for hand-written glue code.

The talk is a general interest introduction to the GNOME Shell - it does not presuppose prior experience programming to the GNOME platform. The talk will start with a description of the design ideas and challenges behind GNOME Shell, and move on to a tour of the shell user interface.

A high-level overview will given of the technology choices behind the shell and the architecture of the shell, with particular emphasis on how they allow rapid prototyping and sophisticated effects with small amounts of code.

The talk will conclude with a look at future work on the shell as we get closer to GNOME 3.0 and how the user interface and technology of the shell can be integrated more deeply with the rest of GNOME.

Traditionally Python has worked one of two ways: either a program with an edit-run cycle or a command prompt where the user types commands. Reinteract introduces a new way of working where the user creates a worksheet that interleaves Python code with the results of that code. Previously entered code can be changed and corrected. The ability to insert graphs and plots in the worksheet makes Reinteract very suitable for data analysis, but it also is a good for basic experimentation with the Python language. This talk introduces Reinteract and gives a high-level peek at the magic behind the scenes.

Instead of editing local files, desktop components and applications now frequently display dynamically changing data retrieved from the internet. The GNOME Online Desktop Data Model provides a complete solution for distributing data and change notifications from the online.gnome.org server and other internet sources to a daemon running in the user’s desktop, and from there to individual applications.

The basic innovation of the data model is that a request for data is implicitly a request for future notification of changes to that data. This talk describes why this concept both fits the needs of the Online Desktop user interface and allows for an efficient client-server protocol. Also covered are accessing the data model from your application, and extending the data model to include new types of data.

GTK+-2.8 introduces Cairo, much advancing the rendering capabilities available to GTK+ applications. This talk covers using Cairo and other new capabilities in GTK+-2.8 to enhance the rendering of widgets and applications using techniques such as vector graphics, alpha transparency and animation. Audience members are discussed to put screenshots and source code of their application or widget on the web and send a link to Owen Taylor for live discussion of enhancing the rendering.

Currently, GNOME has several rendering backends. GDK has drawing code based on the almost 20 year old Xlib APIs. Some parts of GNOME,such as GnomeCanvas render using using libart. gnome-print is yet another rendering API. This mish-mash of rendering technology means that operations that should be simple, such as printing internationalized text in a PangoLayout are hard or impossible.The Cairo library provides a convenient, simple API in front of a sophisticated rendering model with capabilities similar to those in the PDF-1.4 or SVG rendering models. This provides the possibility of a comprehensive solution providing both high-quality display on the screen and printing in a single API. But how will it integrate with Pango, GDK, GTK+, gnome-print and the rest of GNOME? This talk provides a roadmap to how a migration to Cairo could work and how it integrates with existing GNOME technologies.

Open source development methologies have been used successfully for many different types of software, and are just as applicable to the task of rendering internationalized text. In particular, in the area of text rendering, an open-source approach provides the opportunity for local organizations and governments to actively contribute to development of support for scripts with smaller user communities, rather than simply waiting for for the software vendor to provide such support. The Pango project provides a highly modular framework for internationalized text layout and rendering, with the ability to incrementally add support for both new scripts for new new font technologies and rendering systems.

This tutorial covers the essential concepts needed to become an effective programmer with GTK+ user interface toolkit.

Topics covered include -

• The basics of the GObject system: inheritance, signals, and properties.
• The principles of GTK+ window management
• Laying out a GUI using Glade
• How to organize a GTK+ program
• Creating lists displays using GtkTreeView

Attendees are expected to have a familiarity with C. No prior experience in GTK+ or GNOME programming is needed.

This talk covered the design of a new file selector for GTK+-2.4. Covered are potential user interface and API elements, integration with the desktop, and a sketch of a proposed API.

This talk was a brief tutorial that introduced GTK+ programming and coverered some important concepts that new GTK+ programmers frequently have problems with, and some useful strategic hints.

The 2.0 development cycle was, by far, the largest step in GTK+ development ever; the size of the code more than doubled to over 600,000 lines, significant contributions were made by dozens of individuals adding major new functionality such as completely new text and tree widgets and much expanded internationalization support. With a more ambitious development cycle, considerations of design, process and communication became more important.

By looking at how tools such as bugzilla and mailing lists were used in development, how design decisions were made, and how scheduling was done and worked out in practice, we can extract both successful practices can be used in other projects, and improvements that need to be made for future GTK+ development cycles.

Advancing the user experience on the open-source desktop depends upon creating standards for applications to interact with each other and the desktop environment so that applications created with different toolkits operate correctly with any desktop. The XSETTINGS protocol provides a simple example of some of the techniques and considerations that come into play for such standards. It provides a mechanism for all applications running on a desktop to have access to a common set of settings for such user-configurable parameters as double-click time and background color.

Pango is a library for laying out and displaying internationalized text. It handles almost every writing system in the world, and can work on top of multiple different display systems - including traditional X fonts, or client-side OpenType fonts. Pango is used for all text handling in the soon- to-be-released version 2.0 of the commonly used GTK+ widget toolkit.