Bonobo

Executive Summary

Bonobo is the GNOME architecture for creating reusable software components and compound documents.

Bonobo was designed and implemented to address the needs and problems of the free software community for developing large-scale applications.

Availability

The latest version of Bonobo is available on the GNOME CVS repository.

We make regular releases of the source code on the FTP site.

Screenshots

You can see Bonobo in action.

Bonobo supports arbitrarly shaped components.

Applications using Bonobo

Various applications include Bonobo support to various degrees (this is by no means a complete list of Bonobo-aware applications):

• The Gnumeric Spreadsheet. (CVS module: gnumeric)
• The GNOME postscript viewer (CVS module: ggv)
• The GNOME PDF viewer (CVS module: xpdf)
• The Gill SVG viewer (CVS module: gill)
• The Nautilus Graphical Shell (CVS module: nautilus)
• The Evolution groupware suite. (CVS module: evolution)

Mailing lists

The Bonobo architecture, its use and applications are typically discussed on the gnome-components-list@gnome.org mailing list.

Extended description

Motivation

Modern applications are increasingly functional and more powerful. As these applications grow in terms of functionality and features, the internal complexity of these applications increases as well.

As applications become larger, the task of maintaining the code becomes harder: re-targeting the internals of applications takes more programmer time, changing the code becomes more difficult and doing a re-design on the applications while being compatible takes a large amount of time from the core developers to push an application into a new direction.

Adding complexity to a software project is extremely simple, and once the projects goes down that road, the barrier for free software programmers to contribute to a given project is increased. Once the complexity barrier has been raised, the time a developer needs to get acquainted with the code and feel comfortable with the over-all architecture to start contributing is raised forever.

Given the nature of the GNOME project, of being a system that is pretty large and consists of multiple applications, it is very important for us to keep the code as simple as possible. Choosing simple, clean and correct design takes precedence over other constraints whenever possible.

Software created by the free software community has been historically done by hobbyists on their spare time working on the things they are interested in. Unlike other software projects, the contributions of individuals to a project can disappear and stop contributing at any point, without further notice.

The Bonobo component system has been designed to solve these problems and the problems derived from the facts outlined above.

Component software helps reducing the complexity of applications by reducing the amount of information a programmer needs to know about the system. This is achieved by making each software component implement a very well-defined interface (note: these interfaces are CORBA interfaces specified in the CORBA Interface Definition Language).

Component software also enabled programmers to build larger, more complex applications by glueing different components together into bigger applications. For example, you can use a Gnumeric spreadsheet component for entering tabular data in your application. You can use an HTML display component to embed HTML text into a region in your application; You can embed a plotting component to add graphic capabilities to your application; You can use an scalable vector graphics (SVG) component to display, edit and manipulate SVG files in your application.

Bonobo is the GNOME foundation for writing and implementing reusable software Components. Components are pieces of software that provide a well-defined interface and are designed to be used in cooperation with other components. In the Bonobo universe, CORBA is used as the communication layer that binds components together.

The magic behind component programming is in the "interfaces" that component export to the world. Each one of these interfaces is a "socket" into which other components and applications can plug into. These interfaces are defined in terms of CORBA interfaces.

One added benefit of basing the component system on top of CORBA, is that programs written in any language can use components written in any other language. The only requirement is that the components agree on the CORBA interfaces used. In the case of the Bonobo architecture, we have provided a number of interfaces that define the interactions required for this to work. By having components implement the Bonobo interfaces, they will work along any other Bonobo-based components.

A Bonobo Roadmap

Bonobo is a set of CORBA interfaces that define the interactions required for writing components and compound documents. These CORBA interfaces are not bound to either GNOME, the X11 windowing system nor the UNIX system.

The Bonobo distribution as shipped by the GNOME project includes the Bonobo CORBA interfaces, and a GNOME/GTK+ based implementation of these interfaces.

The implementation of Bonobo as shipped is designed to make the process of using and interacting with components in a very simple way: our goal with the GNOME implementation of the Bonobo interfaces was to enable the GNOME/GTK+ user base to become productive with Bonobo in little time. Thus, Bonobo is designed to be simple to use.

Our implementation of the Bonobo interfaces, from now on referred to as "bonobo" is based heavily on the GTK+ object system. The basic principle is that the user is pretty much never exposed to the actual CORBA interface nor the between-components protocol used. Most of the details are taken care of for the programmer and default actions are part of the design. This means that sane defaults will be used unless the user overwrites or modifies the behavior.

Usually a Bonobo CORBA interface is wrapped in a GTK+ object. This means that Bonobo GTK+ objects actually represent a CORBA server that implements the given interface. These CORBA servers as we mentioned before contain default actions and the programmer uses the standard GTK+-operations to alter its behaviors. Programmers would usually hook up to change the behaviors by using the gtk_signal_connect function.

Bonobo is a set of standard interfaces that are used as part of the GNOME project to provide standard component programming in Unix.

Bonobo contains a number of interfaces and libraries that provide a way to create reusable graphical components for Unix systems: instead of creating huge monolithic applications that contain every possible feature desired by the user, the user or the application would use existing components to get their job done.

This is pretty much the same spirit as pipes in Unix: integrating small, simple components that can be integrated to form a flexible and powerful whole.

Bonobo provides mechanisms for creating reusable components, reusing these components and creating compound documents from a collection of components.

For example, the Gnumeric spreadsheet can insert arbitrary Bonobo components into the spreadsheet: this way we can use an equation-display component to render an equation; a plotting component to draw a bar chart and a database component to get live data from a database into the spreadsheet.

Creating complex GUI applications by using available components that can be dynamically loaded: A user could reuse the same plotting component that the spreadsheet uses in his application to display a graph. A GUI designer would allow the user to customize his user interface and the graphic properties. Thus the component would provide all the tools for customizing itself; essentially what Java Beans provides.

Tutorials

Mathieu Lacage and Dirk Jan have written a CORBA and Bonobo tutorial; an HTML version is available online.

Dirk-Jan C. Binnema wrote a tutorial On Writing A Bonobo Control.