The GNOME Project

UNIX has never been considered an extremely user-friendly
operating system. It was designed by techies for techies, and interacting with
UNIX from an arcane command-line shell prompt is a constant reminder of that
fact. Enter GNOME. GNOME stands for GNU Network Object Model Environment. Despite
its complex name, GNOME represents an attempt to simplify using Open Source UNIX
systems likeLinux by providing them with an easy-to-use graphical user interface
(GUI). To quote from the project’s announcement, it is “a free and complete set
of user-friendly applications and desktop tools, similar to CDE and KDE, but
based entirely on free software.” CDE is the “Common Desktop Environment” and is
a commercial (non-free) GUI for UNIX systems. KDE is the K Desktop Environment
and is a competing open source product. [See accompanying article]

Integrated operating systems like the MacOS or Microsoft Windows hide the
fact that it requires many programs working together to create the desktop
metaphor. With Linux, it’s necessary to know a little about how this illusion is
created. Under Unicies, there are esentially three different software packages
that must work together to create a GUI environment.

The lowest level piece of software is the X Window System. X is the
foundation software that directly interacts with the computer’s hardware. It
handles the interaction between input devices (keyboard and mouse), and output
devices (monitor). This enables higher level applications to draw graphics to the
screen and receive input from the keyboard and mouse by just talking to X.
Individual applications don’t have to know anything about how the hardware
actually works. X is provided with all Linux distributions in the XFree86 package
and the GNOME libraries are built on top of the X libraries.

The next essential software component is the Window Manager (WM). The WM
controls the placement and appearance of windows on the screen. It talks to X and
tells X where and how to draw windows. There are many window managers available
that offer different customization options, but all perform the same basic
functions. The Enlightenment Window Manager is the official GNOME WM, but any of
the available WMs will work with GNOME.

The last software package is GNOME itself, which provides the desktop
metaphor. This consists of a series of desktop accessories (like a calculator and
notepad) and the programming libraries that allow developers to create
standardized GUI applications. Programs written under GNOME share a standard look
and feel, and have common functionality, such as drag and drop capabilities.

As its name implies, GNOME can trace its origins back to the Free Software
Foundation’s venerable GNU Project. GNU stands for “GNU’s not UNIX” (it’s a
recursive acronym) and was a project begun in 1984 with the goal of creating a
freely-redistributable UNIX-like operating environment. GNOME builds on top of
the GNU foundation to provide users with an accessible desktop and to provide
programmers with a standardized GUI-programming environment.

Aside from providing users with a friendly desktop, GNOME addresses three
important problems encountered by UNIX programmers:

* Lack of a framework for writing consistent and easy-to-use GUI
applications.

Before we explore how GNOME works its magic to solve these problems, a brief
history of the project is in order.

A Brief History of
the GNOME Project

Before there was GNOME as it exists today, there were two other
projects — the “libapp project” and the “old-GNOME project.” Libapp was intended
to supply programmers with a standardized method of creating GUIs for their
programs. Old-GNOME was going to provide UNIX with a standard software component
model that would allow any program to talk to any other program using a defined
set of interfaces.

Welcome to GNOME: A screenshot of the GNOME login screen.

When the KDE project emerged as a serious attempt to create a usable desktop
environment for UNIX, a number of people became slightly concerned. The KDE team
had chosen to build their project on top of the Qt GUI tool kit, which at that
time was not truly “free software.”" ALThough Qt has since changed its licensing
terms and now qualifies as free software, at that time many people felt its use
represented a step backwards for software freedom. This led to the emergence of
the GNOME project as an attempt to develop a completely free desktop environment
based on the original old-GNOME and libapp ideas.

The people on the original GNOME team had a good mix of backgrounds revolving
around free software issues, graphics, and programming language design. The
original team included the programmers who workedon the GNU Image Manipulation
Program (the GIMP), Peter Mattis and Spencer Kimball. Richard Stallman, the
father of the GNU project, was involved, as were Erik Troan and Mark Ewing of Red
Hat. Additionally, there were significant contributions from the members
of the Free Software and GUILE mailing lists. (GUILE is GNU’s Unique Intelligent
Language for Extensions, a programming language that can be embedded in other
programs to make them extensible through scripting. GUILE was one of the first
scripting languages usable with GNOME.)

Since the project’s inception, there have been regular releases of the GNOME
source code base. After 18 months of development, GNOME 1.0 was officially
released in March 1999. Updates and bug fixes are being released on a continual
basis, and as of this writing, the GNOME 1.0 series is at version 1.0.5.

GNOME 1.0 is a significant milestone in the history of the project because it
represents a contract between the GNOME development team, independent software
developers, and users everywhere. Release 1.0 provides a stable Application
Programming Interface (API), on top of which new applications can be developed.
Independent developers can take advantage of all the functions available in the
libraries and they can be assured that their applications will continue to work
in the future.

The GNOME Desktop:
A User’s Point of View

User-Friendly: GNOME’s file manager, word processor, and
spreadsheet.

GNOME gives users an intuitive desktop metaphor, a file manager, an
easy way tolaunch applications, and built-in support for “themes”, which allows
users to change the appearance of their desktop and applications. For example,
“steel” themes make the desktop and applications appear to be made of steel, and
a “wooden” theme would make them appear to be made of wood. Various desktop
productivity tools and other standard goodies are also included.

The GNOME desktop can be used to store files and shortcuts to programs. In
addition, drag and drop capabilities are integrated with the desktop, allowing
objects to be moved through the file system in a very intuitive manner. GNOME
also facilitates access to printers and other hardware devices by making these
resources directly on the desktop.

The environment’s “themes” support means users can configure a
GNOME-compliant application to look almost any way they want it to. GNOME comes
with numerous pre-designed desktop themes and others can be found athttp://gtk.themes.org — a web site dedicated to themes. Keep in mind that some
Window Managers come with their own support for themes. These are totally
independent of GNOME’s themes. For example, the Enlightenment WM has its own
themes that differ from GNOME’s (yes, it’s confusing).

Another key feature is GNOME’s support for”session management,”allowing it to
remember the state of the desktop between logins. When users log in, they see the
same desktop and running applications that were in use when they last logged
off.

Some GNOME Applications

There are an increasing number of GNOME-compliant applications available. Some of
the most popular are:

Image Manipulation Program (the project that started it all). The GIMPis a
powerful image editing and painting application. It performs common image
manipulation functions such as painting, color correcting and cropping. It also
supports advanced features such as lay-ers and selections, and is extensible via
a complex plug-in system. The plug-ins are separate programs that provide
specialized image manipulation functions or special effects.

* GNUmeric –A powerful spreadsheet application. GNUmeric has
all the features you would expect fromany commercial offering, but is free
software. An exceptionally useful feature of GNUmeric is its ability to import
and export Excel files.

* Guppi –A basic graphics application. This is also the tool
that GNUmeric uses to plot graphics.

* AbiWord – a full-featured word processor that uses the GNOME
libraries as its engine, and will take full advantage of all of GNOME’s component
technology. This means users can link and embed spreadsheetsfrom GNUmeric or
graphics from the GIMPinto AbiWord documents, or link AbiWord documents back into
those programs.

GNOME As a Development Platform

While GNOME can certainly make UNIX-based operating systems more palatable to ordinary users, it also
providesmany benefits for the development community.

The core of the GNOME project is a framework of libraries that allows
developers to build new GUI applications that have access to a fixed set of
system services (e.g. — printing) and with a standard “look and feel.” The API
was designed with the goal of programming language neutrality in mind. The GNOME
team wanted all programmers to be able to take advantage of this system and
therefore the libraries must be accessible from a wide variety of languages.

The GNOME Foundation libraries

Entertain me: GNOME offers the user several multimedia
applications.

GTK+ — (GIMP Toolkit) GTK+ is GNOME’s object oriented graphics toolkit. It was
originally designed by the GIMP programmers to simplify their work in building
the GIMP. GTK+ was chosen primarily because it implements an object system rich
in functionality and because it already had interface bindings for a wide range
of programming languages. This meant that GTK+ already went a long way towards
achieving GNOME’s goal of programming language neutrality.

Guidelines have been developed specifying the method for adding newlanguage
bindings (wrappers) for the GTK+/ GNOME libraries. Developers following these
guidelines have contributed support for a number of languages including C++, TOM,
PERL, Python, GUILE, ADA, and others. Other bindings are in various stagesof
development, which is understandable, considering the large number of libraries
that make up GNOME.

GTK+’s object system is very elegant in its design and allows for classical
single-inheritance, dynamic creation of new methods and classes, and a “signal”
mechanism that dynamically attaches “signal handlers” to events that occur in the
user interface (e.g. — a mouse click).

Another reason for choosing GTK+ is that it advances the second goal of the
project — to create an intuitive desktop metaphor. It does this by providing
support for two drag-and-drop protocols — the Xdnd (X Drag and Drop) and Motif
DnD. This makes it possible to drag and drop objects between programs written in
GNOME (like the desktop), and programs that were written using other tools (like
Netscape). Because all this is handled by GTK+, application writers get this
functionality for free.

Imlib: This is an imaging library and engine that provides for
fast loading, saving and displaying of images. Imlib provides sophisticated image
caching and color management functions, which operate efficiently even on low-end
displays or 8-bit video cards. Due to limitations in X’s color management scheme,
developers writing directly to the X Window System libraries and artists creating
icons or images for X need to be concerned about how many colors a given image
might use. Imlib frees them from these worries by providing automatic color
reduction and dithering facilities.

XML/DOM Libraries: The WWW Consortium (the organization that
ratifies standards for the World Wide Web) recently introduced two new standards
– XML and DOM. XML is the Extensible Mark-up Language, which can be used to
describe and create other mark-up languages such as HTML. DOM (Document Object
Model) describes how applications can modify chunks of data in an XML or HTML
document. Implementing these standards as a GNOME library makes it easier for
programmers to write XML/DOM- aware applications.

The Canvas/Libart Engines: The Canvas is an engine for
creating structured graphics that allows programmers to easily create interactive
graphics displays. Its features include unlimited scrolling andcompletely
flicker-free operation. The canvas is designed to be an extensible, but generic
display engine. The GNUmeric spreadsheet application, for example, uses the
Canvas but provides its own custom extensions. Applications like the GNOME
calendar and the Midnight Commander file manager use the basic functionality of
the canvas in their displays.

Libart is a vector manipulation and rendering engine that uses anti-aliasing
and alpha-compositing. The canvas is built upon Libart and uses it to perform
efficient screen updates via a microtile array. It also uses Libart to create
anti-aliased, alpha-com-posited output. This
provides a superset of the PostScript imaging model for extremely high-quality
displays.

The Bonobo Component and Document Model:Bonobo is not a
programming library per se. It is a framework similar in concept to
Microsoft’s Object Linking and Embedding (OLE). Bonobo allows programmers to
create reusable software component objects (similar to “Active X Controls”). It
is also a document model that defines asystem where these objects can seamlessly
interact within shared “container” documents (Similar to Linking and Embedding).

To use a Microsoft example that most people are familiar with, in Microsoft
Office, an Excel document can be “embedded” within a Word document (or vice
versa). The Word document in this case is a “container” document. It contains
both the Word data and the Excel data. However, clicking on the Excel data
allowsyou to work on it as though you were working in Excel, even though it is
embedded in the Word document. The Excel application functions as a piece of
“component” software, creating the illusion that the user is only interacting
with one application.

The Bonobo component architecture is based on CORBA technology (Common Object
Request Broker Architecture) and is integrated into the GTK+ object model. What
CORBA is and how it works will be discussed shortly, but its use in Bonobo means
that programmers can easily create component software by simply utilizing GTK+’s
“signal” mechanism.” ALTernatively, they can gain CORBA functionality by creating
components that inherit from a GTK+ based class. The beauty of this is that
programmers do not need to know anything about CORBA to take advantage of it in
Bonobo.

Please also note that while many programmers associate OLE with great
complexity, much of that is due to the way Microsoft was forced to design OLE so
that it would work well with Windows. While sharing much of the same
functionality as OLE, Bonobo is inherently a much simpler system to understand
and design software with.

The Common Object Request Broker Architecture (CORBA)

Now that we have a good grasp of GNOME’s features, let’s take a look at its
underlying architecture. UNIX has long been praised for the fact that users can
take a bunch of small, filtered programs (like grep, sed, or any other UNIX
command) and tie them together using pipes to compose a more complex makeshift
“program”. Sadly, pipes and filters do not scale to more complex applications
(especially graphical applications). GNOMEis an environment where software
“objects” can “talk” to each other (even over networks) in a standard fashion
without knowing anything about each other, and this is made possible by GNOME’s
CORBA foundation.

CORBA is a software system based on completely open standards and specifies
methods for software objectsto interact with each other. These objects speak to
each other through an “Object Request Broker (ORB)”, which directs traffic
between all of the different pieces of software. The CORBA standard specifies the
functionality that an ORB must provide to client programs that make requests of
it. This creates a standardized method for any software object to talk to any
other software object by communicating through the ORB. The objects don’t need to
know anything about each other; they can be programs that can be written in
different languages and perform different functions, and they can even be located
on different machines. As long as they communicate through the ORB, they can all
speak to each other.

CORBA is woven throughout GNOME and provides application developers with a
rich set of services. Among them are:

A general IPC mechanism (Inter-Process Communication):In the
past, it was quite common in a UNIX environment for programmers to want two
processes (applications) to communicate and to invent a customized protocol for
doing so. Needless to say, the situation did not do much to encourage software
reuse or interoperability. Now, whenever GNOME applications need to communicate,
they can just use CORBA.

A means of exporting an application’s internal engine: Various
applications in GNOME export their internal functionality to the outside world.
This allows other programs — both GNOME and non-GNOME — to use the services
exported by an application, making these applications espe-cially accessible to
scripting languages. This means advanced users will be able to write scripts that
automate common tasks. In the not-too-distant future, users will be able to write
Python scripts to manipulate a GNUmeric spreadsheet, perform customized spell
checking, or automate repetitive presentation creation tasks.This is similar to
the functionality that Microsoft’s Visual Basic provides for MS Office under
Windows. The Guppi graphics application, the file manager, and the GNUmeric
spreadsheet are currently scriptable in this fashion.

A method for creating re-usable, interoperable software components:As previously mentioned, the Bonobo component and document model
expandsupon the services CORBA offers, creating a framework that offers both
programmers and users a very high level of flexibility.

ORBit

CORBA is a series of specifications for designing Object Request Brokers (ORBs),
but it is not an actual piece of software. Many ORBs have been written to the
CORBA specification, but they are all implemented differently, and not all of
those ORBs suit every software project’s needs. The GNOME team spent a long time
searching for a suitable CORBA implementation. They required an ORB that
supported C language bindings and that was both thin and fast. Eventually, a
decision was made to write a CORBA ORB from scratch. Dick Porter, Elliot Lee
(while working for Red Hat Labs), and Andrew Veliath wrote an all new
high-performance CORBA ORB named ORBit. ORBit finally provided the “plumbing”
that allowed the team to deploy CORBA throughout GNOME.

Programming Tools

As the GNOME system matures, new development tools are emerging
to aid developers in designing GUI
applications. Of particular interest
is Damon Chaplin’s “Glade”. “Glade” greatly simplifies the creation of complex
UIs in much the same way that NeXT’s Interface Builder simplifies this task under
NeXTStep.

Databases can now be accessed in a uniform fashion through the GNOME DB,
which is a modified CORBA interface to various databases. GNOME DB also includes
a designer front-end. This project is being managed by Michael Lausch, who
handles the back-end and CORBA elements, and Rodrigo Moya, who is writing the
GUI-builder code.

The GNOME Printing Architecture

The free software community and UNIX in general has long lacked a
standard printing architecture. GNOME provides a sophisticated printing engine
intended to standardize the way applications utilize the printing subsystem.

GNOME-print [GPRINT] is the implementation of GNOME’s printing architecture.
It consists of a pluggable rendering engine, and a set of standard widgets and
dialog boxes for selecting and configuring printers. In addition, GNOME-print is
responsible for managing outline fonts and contains scripts that automatically
find fonts already installed on the system.

At the time of this writing, GNOME-print generates only PostScript output.
However, the design of the imaging model is closely linked to the rendering
engine for the Canvas, and it is expected that these two modules will soon be
interoperable. In particular, it will be possible to “print” into a Canvas, which
is useful for providing a high quality “print preview”, and it will also be
possible to print the contents of a Canvas. This feature shouldsimplify the
design of applications that use the Canvas, as little extra code will be needed
to support printing.

The GNOME-print engine will also be used to render printed pages directly
without going through an intermediate PostScript step. This is especially
exciting because it will allow high quality, high performance printing to color
inkjet printers. These printouts can be complex pages containing transparency,
gradients, and other elements considered “tricky” in the traditional PostScript
imaging model.

It is also possible to get the very latest GNOME developments from the
anonymous CVS servers. Check the GNOME web page at http://www.gnome.org for
details on how to pull the latest version straight from the CVS servers.

Breaking news is also posted to the GNOME Web site. Also available there are
documents to get you started on installing GNOME and on developing GNOME
applications. The GNOME FAQ is especially helpful, so check it out if you are in
need of assistance.

How Can You Help With GNOME?

The GNOME project welcomes people who want to assist in creating the
best possible Open Source desktop environment. There are opportunities for all
kinds of talent to be utilized. If you would like more information on how you can
help out, please e-mail webmaster@gnome.org.

Advertiser Disclosure:
Some of the products that appear on this site are from companies from which QuinStreet receives compensation. This compensation may impact how and where products appear on this site including, for example, the order in which they appear. QuinStreet does not include all companies or all types of products available in the marketplace.