This paper aims to show how Sun Microsystems, Inc., uses translation technology for its translation activities on GNOME and other projects.

Primarily, we will share our experiences of how the use of open standards such as XML Localization Interchange File Format (XLIFF) and Translation Memory eXchange format (TMX) and the use of tools to process these formats can increase translator productivity and aid in the sharing of translations across multiple projects.

We will demonstrate our translation editor which has been developed in-house and has been in use for several months on real-world translations. In keeping with our tradition of supporting open standards, our editor can load and save XLIFF files and can export TMX files for use with other translation tools. We have had extensive feedback from professional translators who have been using the system in production and we will explain some of the features that were added to accommodate their needs.

Finally, we will present our vision of translation technology and the advantages it can bring to increase translator productivity and translation accuracy.

Two of the historically core GNOME libraries are libgnome and libgnomeui. Over the past couple years, they have shrunk in size as their functionality has slowly moved to more specialized libraries. Additionally, the focus of the libraries has changed from providing a random collection of features to providing desktop integration. In this talk, the current maintainers discuss what they hope to do with the current libgnome codebase, and their vision for the future of the module.

GtkMathView is a GTK+ widget for rendering of and interaction with MathML markup. Although free interactive applications for math are available none of them can be easily treated as a light-weight, customizable component. GtkMathView aims at filling this gap by providing a reusable piece of software that can be embedded wherever an application needs to display mathematical formulas.

The need for a specialized widget for rendering mathematics should be evident: mathematical notation is half-way between plain text and free-style graphics. Formatted mathematics usually makes use of glyphs provided in fonts for which no standard encodings exist, hence using already developed components for the layout of text, such as Pango, is of little or no help. Moreover, math formatting is extremely context-sensitive and a large number of parameters must be taken into account: formatting quality, font availability, physical characteristics of the output device are only a few of them. The design of an architecture for math formatting is thus a challenging and interesting problem for which we have found an elegant and adaptable solution implemented in GtkMathView.

The strength of GtkMathView as a component is potentially its most severe weakness: mathematics rarely occurs ``stand-alone'', it is usually embedded within a larger document. However, although the integration of GtkMathView with other widgets (for text or HTML layout) might seem like a straightforward completion, this is more easily said than done. Lots of technical issues arise as soon as one is interested in mixing different markup languages, still preserving natural and flexible exploitation of the displayed information. For this reason GtkMathView understands a simple extension of MathML which allows the embedding of mathematical expressions in larger contexts. This extension has had the welcome side-effect of highlighting parts of GtkMathView's architecture which are not tied to MathML formatting, thus improving the overall modularity of the widget.

In the paper we plan to overview the internal architecture of GtkMathView, to describe the extension markup understood by the widget, and to show GtkMathView's potentialities for the creation of interactive, user-customizable applications involving math display.

Despite its shaping influence on the interactive structures of desktop computing, human-centered design has yet to be seriously applied to the file system. GNOME Storage is an evolving design and implementation for a document store that addresses many problems stemming from traditional file systems. Some of the problems are: document folders are overflowing with hundreds of files, there's a strong separation on desktop computers between desktop and application, there's a strong separation between local and remote resources, most applications do not support real-time collaboration using multiple computers, localizing basic file system structures is very hard, and applications use a save-buffer model rather than presenting documents as concrete objects. We discuss these as design goals and how they are solved in the Storage implementation, in addition to providing a theoretical framework for understanding the file system's role.

The desktop can be a powerful or an intractable barrier to the computer user who is a person with a disability. Recognizing this, many countries around the world are adopting laws and policies giving preference to technologies which are accessible to, and usable by persons with disabilities. We will examine what this means and how persons with various disabilities use computers at home, at play, and on the job. Through the work of the Free Standards Group Accessibility Work group, we will review progress in making today's desktop accessible and provide a road map for future work.

This talk will discuss how to add functionality to Nautilus using the new extension system added in GNOME 2.6. This system allows development of in-process extensions that integrate tightly with Nautilus' existing infrastructure and file views.

In GNOME 2.6, extensions can supply:

• Extra columns in the list view and icon details in the icon view.
• Pages for the file property dialog.
• Emblems for specific files.
• Context menu items for file selections, and per-folder menu items.

In addition to basic information on implementing these extensions, this talk will touch on Nautilus' asynchronous IO model, migration from old-style Bonobo extensions, and adding support for new languages. We will go over example code in C and C#.

With the new technologies, the way people are used to interact with computers is changing. A new key piece is "Mobility": mobility of users, data and computing. As a modern desktop, GNOME needs to support mobility in some different areas, but finally, in a transparent way for users. The main goals are:

• Get your stuff everywhere: People should access their music, their docs, and their media everywhere. File Sharing technologies are the main point here, they are mature, but they need integration.
• Get your preferences everywhere: every computer in the world should be "the same" for user Bob. The Desktop should manage this transparently. With GNOME this could be implemented using a remote backend for GConf and lot of hackery.
• User is moving, so he needs old and new services: WiFi, UMTS combined with mobile IP will bring the user network everywhere, and with that, all the old services he used, but new services and some modifications to existing ones are required to bring him information dependent of position.
• New mobile devices should be supported: sharing information with PDAs, mobile phones and every network aware device is a must. Regardless if they use GNOME or not, protocols as SyncXML should allow GNOME Desktop applications (Calendar, Contacts, Personal Info...) share and sync their data with these devices.

Bluetooth allows wireless connections between computers and mobile phones, PDAs, printers and other peripherals. The Linux kernel has Bluetooth support, and work is underway on FreeBSD. This talk will briefly explain the major points of Bluetooth support, and introduce the GNOME Bluetooth subsystem.

The subsystem provides an architecture for giving GNOME applications easy access to Bluetooth facilities, aiming also to provide a straightforward user experience. It comprises a GObject for direct access to Bluetooth facilities, system-wide management of devices and applications for common Bluetooth tasks like file transfer.

The GNOME Bluetooth work was first presented at last year's GUADEC. Since then the code been somewhat rewritten and is nearing its 1.0 release, and has been added into the GNOME CVS repository.

Python bindings have been added, and some simple Bluetooth programming will be demonstrated.

In this session, I would like to share our experiences on interacting with the local community. I would talk about the challenges that we have faced and resolved. I would also like to take inputs from the participants on how we could increase the community base. This should be of interest for people who are involved in local GNOME chapters.

I will outline a general mish-mash of documentation-related topics, whet everybody's appetite, and disappear mysteriously into the night. There is a lot of potential goodness for free software documentation efforts, and I will provide an overview of how the GNOME Documentation Project can be a leader and an innovator in the documentation world.

Document creation and management has traditionally been a chore. Though DocBook is in many ways a step forward, it is often more difficult for authors than other document formats such as LaTeX. I will discuss the sorts of wonders that will be possible with Norman Walsh's developments on the next generation of DocBook, and I will reveal my four-step plan for creating a structured document editor. I will also mention MathML at least once.

Document organization and categorization has always been a hard problem, and many different approaches have been taken by different help systems over the years, with varying degrees of success. I will compare some of these approaches and discuss what we can learn from them. I will also discuss topic-oriented documentation and how we can make documentation easier to find, including ideas for integration with new context-aware technologies such as Dashboard.

Finally, I will discuss ideas on making document navigation simpler by shedding the browser-like interface of Yelp and focusing on the logical structure of our documentation.

The GTK+ and GNOME APIs have grown big over time with the addition of new widgets, desktop-wide concepts, and improved versions of their old counterparts. Applications which predate these new features are often not modified to use them, so they may be missing important things which are part of "well-behaved" applications. Some of these features include aids for keyboard navigation, performance improvements, multi-screen support, theme compliance, robustness for components, and authentication. In this talk I will explain what these features are, and how they should be used to make applications Do The Right Thing.

The line separating the computer from the network is becoming more imaginary. Bandwidth increases, storage gets cheaper, and data gets bigger. Distributed computing becomes fashionable, and replication becomes important.

It's insidious. You don't know it's happening until one day you find a large majority of your developers working on what amounts to replication, in different forms, with different requirements, even in completely different projects, encountering the same trade offs from different angles. On that day, we decided we'd had enough.

This paper sheds light on the above, describes replication's requirements and inherent compromises, and puts forth an "optimal compromise" leading to a general solution that should be useful in any project.

WvSync is the start of an open-source implementation of the general solution, using our WvStreams networking library. Think of it like multidirectional rsync; you can make changes on any node, or on multiple nodes, and the changes will be reflected everywhere. It can be used to synchronize files, database records, email, calendar entries, etc.

After discussing the general solution, this paper illustrates WvSync's design, shows how it can be used to synchronize arbitrary objects in any project, and describes future directions the project may take.

This will be followed by an amazing, earth-shattering, mind-boggling, yet heart-warming demonstration.

Digital Photography in the last years has been the most dynamic market for photography products. Ever since the first consumer products that appeared in the mid 90s, UN*X users have been attempting to use them with their favourite environment. A few open source projects have given photographers ways to access their photos off either digital cameras or scanners from UN*X. I'll try to explain the different means of accessing these, depending of the media, and I'll try to cover tools and API available for GNOME users and developers.

SANE is the ultimate scanner driver for Linux. It provides drivers for more that 48 scanners families (each containing up to a few dozens of models) and more importantly a software architecture to use these drivers from various applications, including the GTK+ enabled frontend XSane.

libgphoto2 is a library that allow you to access more than 400 different cameras over USB or serial port, in addition to the already supported cameras that use the USB Mass Storage protocol. Gtkam, its GTK+ frontend has been around for a while giving GUI access to the libgphoto2 features.

Around these two components, there are a other tools to manage and edit the pictures. The master piece is the well known Gimp, but we'll see that there are a few plugins that may be of good use, like Pandora or dustremove ; as well as browsers like gqview or Nautilus.

Basic building pieces for digital photography in GNOME are here, but there are still areas were improvements can be made.

ORBit2 and Bonobo are the CORBA based Middleware of GNOME Desktop, being used for every Panel-Applications and GNOME-Component. This talk will focus on new security features of ORBit2, like IIOP over SSL, providing confidentiality and integrity for interprocess communication for all GNOME applications. Code samples will demonstrate usage of new security features of ORBit2 for implementations of server and client applications. SSL will be presented in detail, how it should be used and what should be avoided, talking about Cipher-Suites and Public-Key-Exchange mechanisms. Addressed are developers with knowledge in C, C++ or Python.

During a 1 hour presentation, I will present the basics of a GIMP plug-in, including a plug-in's basic elements, the libgimp API, accessing image data efficiently, and using the PDB to make our plug-in available to scripters.

Many people are intimidated by the GIMP, and imagine that writing a plug-in would be a difficult task. The objective of this presentation is to show that there are very few difficulties to writing a plug-in in C, once we know the basics.

During the presentation I will implement some image processing algorithm (not too complicated), and time permitting I might make an options dialog too. I will then illustrate the use of the plug-in, both interactively and via a script.

OpenOffice.org is a full fledged, international, open-source office productivity suite. It is available on a large variety of platforms, including Linux, Windows, Mac OS X, FreeBSD, and many more. Only tiny portions of the codebase are platform dependent and subject to actual porting effort.

Though portability has its merits, it does come with a price: lack of integration into the user's desktop environment. This becomes most obvious in the visual appearance of the application. Despite using the system's colors and user interface font, the basic appearance is the same on all platforms, never really sharing the look and feel of other applications designed for the desktop.

We present a solution to bring the GTK+ look to OpenOffice.org without compromising portability. By directly attaching to the system's theming engine, our approach preserves Openoffice.org features like accessibility and Right-To-Left user interface as required for Arabic and Hebrew localizations. As a result, OpenOffice.org will follow the current desktop theme on the targeted platforms, including effects like mouse-over, prelight, and control focus, as well as support for on-the-fly theme switching.

Further integration improvements will also be implemented. For example, there should be no need to configure in OpenOffice.org what has already been configured in the system, from the printing environment, mailer, and browser settings, to other settings like fonts and proxies. Additionally, OpenOffice.org extensions to Nautilus will make meta data like author and version information available in the document's properties dialog.

Presentation outline:

• The OpenOffice.org Native Widget Framework (NWF)
• Dealing with different approaches in widget design
• Load on call platform integration
• Reusing system's settings (Fontconfig2, CUPS, Gconf) in OpenOffice.org
• Nautilus extensions
• Future work
• Live demo

The importance of metadata within the GNOME desktop is becoming increasingly recognised. Projects such as Dashboard, Storage and Medusa aim to make the user's life easier by making their data more findable, using a combination of metadata and search technologies. Competing desktops are implementing metadata-aware filesystems -- such as Microsoft's WinFS -- as part of the next generation of their offerings.

This talk presents some of the issues we will face implementing general metadata throughout GNOME, and an introduction to the metadata standards landscape, covering not only the technologies but also the software toolkits available and suitable for use with GNOME. Special emphasis will be given to the application of these technologies to GNOME development.

The main standard covered will be the W3C's Resource Description Framework, RDF. It will be placed in context with competing and complementary technologies such as W3C XML Schema and RSS.

Programmers often don't get exposed to graphic design theory; it's easy to imagine it's all about wishy-washy artsy stuff or that it isn't important or useful.

In fact, graphic design is a mix of clear and scientifically sound principles and aesthetic judgment. An understanding of the underlying principles will help you communicate more effectively. You can use these principles when you build dialog boxes and program windows as well as when you make Web pages or printed designs.

Liam Quin has a background in typography and design as well as in computer science. He's designed published books and given courses on typography and layout for twenty years. Liam is currently the XML Activity Lead at the World Wide Web Consortium, and has been using SGML and structured markup SGML since 1987; he was involved in the design of XML.

FreeDesktop.org has now become an effective magnet for competing and allied desktop technologies, in broad-based recognition of the need for creating and accepting common desktop standards in the Free and Open Source communities. Sharing the same site, and in support of the same conviction, X.Org has re-formed as the XOrg Foundation, a free and open membership organization, whose purpose is to drive X and associated technologies to timely innovation more effectively to meet future demands of the cross-platform desktop and network.

MAS*, X.Org's endorsed effort to provide an integrating technology for pluri-modal media, compatible with and supporting X, has been under development, integration, and testing for 5 years. MAS integration in Gnome, providing full audio support for native Gnome applications, will be complete this spring. We will present and discuss the following issues concerning the future role of MAS on the standard free desktop.

• Specification for an integrated sound server.
• ESound, OSS, ALSA, and other standard specifications.
• The MAS API extension required for an ESounD surrogate.
• What did we do with ESounD?
• Replacing the ESounD API with the core MAS API.
• How to write audio applications in Gnome using the MAS API and MAS devices (MAS-DPI).
• How MAS and X work together.
• MAS support for integrated sound and video. MAS synchronization of media data streams. Writing media applications for Gnome using MAS.
• The MP3 problem and the approach we have taken; the status of Ogg and the Fraunhofer patents and licenses.
• Network distributed media applications, using MAS-enabled X.
• Finding common the architectural ground for GST, kde-media, Jack, MAS, etc.
• Working together.

The idea of an "Open Desktop" is lot more broad than that of an "Open Source Desktop". Technological differences make it often impractical to share code and thus standards become the solution to the problem of interoperability between desktop environments. In this talk I will go over the currently shared standards between KDE and GNOME desktop environments. The focus of the presentation will be the look at the feature with a strong emphasis on the possibly shared: IPC mechanism and configuration system.

The topics covered will include:

• already existing and used standards such as the desktop base directory and menu specification,
• inter-process communication mechanisms - CORBA, DCOP and DBUS.
• configuration frameworks - KConfig, GConf, XSETTINGS.
• look at the future - discussion of newconf, shared default keyboard shortcuts and MIME run actions specifications.

Cairo is a vector graphics library with cross-device output support. There are plans for basing either the next generation, gtk+ or gnome canvas on cairo. One of the existing prototypes gtk+/Cairo integration is GtkCairo.

In this talk, I'll give an introduction to programming with Cairo's imaging model, focusing specially on issues relating to integration with gtk+, and deriving GtkWidgets using GtkCairo, maintaing a consistent look and feel with the rest of the gtk+ widget set. During the presentation I will demonstrate codeand usage of both simple and advanced GtkCairo widgets.

How cairo eventually will be integrated with gtk+/gnome in the future isn't quite sure yet, but Cairo's base API won't change, thus code created using GtkCairo; will easily be adopted to future interfaces.

HAL is a hardware abstraction layer and aims to provide a live tree of devices present in the system at any point in time. Each device has a number of properties defined that can stem from several sources including the hardware itself or from device information files matching a specific device.

Desktop environments, like GNOME, can communicate with the HAL through a system-wide message bus for querying of devices and asynchronous notifications when device properties change and devices are inserted/removed. By itself HAL doesn't support configuration or operation of devices, but it allows future or existing device-specific abstraction libraries like libgphoto to use the information exported by HAL.

HAL is designed to support a number of operating systems given sufficient infrastructure and support; presently Linux 2.6 based systems are supported.

An overview of the tools available in GNOME and it's associated libraries that facilitate the creation of applications to read, display, and write documents. There are a number of high quality applications using Gtk+/GNOME many of which have split out useful pieces. From Gnumeric and libgoffice's plugin system, to libgsf and it's i/o wrappers new projects have a wealth of useful tools available to them.

The tutorial will walk through creating the shell of an application with examples and discussion of where to pick up everything from default autoconf/automake and command line parsing standards, up to sources for useful menu/toolbar widgets and plugin frameworks. We will finish off with a discussion of the available application UI frameworks (gtk, gnomeui, bonobo) comparing portability and utility.

Michaels talk is unfortunately cancelled due to illness.

This talk will examine Free software development infrastructure for the desktop, and compare and contrast pieces of gtk+, gnome, OpenOffice.org, freedesktop.org, Mozilla, KDE/Qt, Java, Mono and other hunks of code.

I'll also try to present an approach for cleaning up the mess, and discuss the perennial problem of conflicting standards: the creation of yet another conflicting non-standard. Some nirvana of clear direction, inter-project communication, and code sharing will be postulated before we all retire to re-invent the wheel endlessly.

In the end - we'll try to find where Gnome's role in the big picture is and should be, and suggest some strategic directions that may help.

This talk presents new accessibility features in GNOME 2.6 and upcoming improvements in 2.8. New developments presented include powerful new scripting features made possible via the combination of python, PyORBit and at-spi.

We'll also show, for the first time at GUADEC, demonstrations of the "complete" desktop via assistive technologies such as onscreen keyboard and screen reader, including Mozilla, OpenOffice, Evolution, and even have a 'sneak preview' of KDE integration.

We'll also take a hacker-focussed look at some accessibility successes and issues from the 2.6 process, and review the available resources and improvements to accessibility test tools for GNOME developers.

The GST aren't only a set of tools for configuring the system, they are a infrastructure dedicated to make a lot easier the task of writing such tools, as a proof of this concept, the GST are now able to configure (locally and remotely) time, users and groups, network, bootloaders and services configuration in a wide range of Linux distros (and some of these tools work already in other OS like FreeBSD). This BOF proposal is aimed to establish a clear way to follow for post-1.0 (which hopefully will happen in a short term, way before the Gvadec). The issues that might be worth to talk about are:

• BE/FE Communication improvement: right now the communication is not documented and has several customized tricks that makes it work how it does. The communication should be improved to allow an easy access from the greater number of languages/platforms possible
• XML abstraction improvement: since the development of the GST begun, a lot of distro support has been added, providing a wider perspective of the configuration task, and letting the developers realize that several linux-isms, sysv-isms, redhat-isms, lilo-isms... have been used. That should be rethought and improved, all this knowledge should be applied to create XML DTDs that specify truly abstract configuration XMLs
• Use of new technologies: HAL & co are already working and rocking our computers, and GST should take advantage of this when necessary
• New tools: the GST really need to expand their amount of tools, but this growth must be controlled and focused to the users' needs, filling correctly the gaps that exist in the linux desktop configuration

There are many languages in the world, and some of them are cannot input from keyboard directly. Why we cannot input them from keyboard directly? Answer of this question is that, because there are many many characters in the world. For example, the number of kanji characters are over 10,000. So, users of such languages are using systems called 'input method'.

What is input method? The definition of input method is the way to input characters which cannot input from keyboard directly, and there are some way to implement it.

This paper will explain about:

• Fundamentals about input method.
• Gtk+/Gnome's input method support implementation. Gtk+ has a module system to support input method. It called 'immodule'.
• Present input method situation in free desktop.
• Overview of multilingual input method library, called 'uim'. Uim is a library for input method, and aims to provide simple and secure and flexible input method. It's distributed at http://uim.freedeskop.org/