Category Archives: December 2005

Writing a Widget Using Cairo and GTK+2.8

Since version 2.8, GTK+ renders many of its interface widgets with Cairo, a powerful vector graphics library. Davyd Madeley explains how you can implement your own GTK+ widget using Cairo for the actual drawing.

Cairo is a powerful 2-dimensional graphics library designed to support a number of modern graphics techniques including stroking, alpha blending and antialiasing. It supports multiple output formats, which allows developers to use the same code to display graphics on the screen, print them to the printer or accellerate them with OpenGL.

As of GTK+ 2.8, GTK+ has been integrated with the Cairo 1.0 rendering library, giving developers access to this flexible graphics API.

Chapter 1 of this article looks at the more mundane work required to implement a complete GTK+ widget that uses Cairo. Chapter 2 looks at using Cairo to do actual drawing. If you simply want to draw inside an existing widget or simple GtkDrawingArea with Cairo, you can skip straight to Chapter 2. Later chapters will cover emitting signals from your widget and some of the features in the Cairo drawing API.

Step 1. Writing a GObject

While it is possible to simply start using Cairo drawing to draw inside a drawing area, many times you will want to be able to write your own custom widget that you can use over and over again. Much of this chapter can be used for the development of many widgets, not just ones using Cairo.

The first step to writing your own custom widget is creating a new GObject to use with that widget. GObjects can get quite complicated, but we’re going to look at the basics for writing our widget.

GTK+ is an object-oriented environment. This means we have two data structures that we need to worry about: the class and the instance. The instance is the data structure that we are most familar with, it is the GtkWidget struct that we pass around inside our program.

Classes also inherit from other classes. Since we are writing a widget that will be drawn on with Cairo, it will be easiest to inherit GtkDrawingArea, which inherits GtkWidget, GtkObject and finally GObject. GtkDrawingArea already implements a lot of functions we need for our widget and will save us from writing a lot of code.

The class is initialised only once, whereas an instance is initialised every time you create a new copy of the widget. If this is confusing or you are not incredibly familiar with object-orientated programming, don’t worry; we will go into depth with what you can do here in a later chapter.

In clock.c you’ll want to define our new object type:


 G_DEFINE_TYPE (EggClockFace, egg_clock_face, GTK_TYPE_DRAWING_AREA);

We will call our object EggClockFace and preface all of our function calls with egg_clock_face. We are inheriting the type of GtkDrawingArea.

We now need to define structs for our new class and for instances of that class. In our example these structs are quite simple. If we wanted any publicly accessibly variables we could add them here. Private variables are defined in another struct (we’ll get to that). So, in clock.h:

 typedef struct _EggClockFace EggClockFace; typedef struct _EggClockFaceClass EggClockFaceClass; struct _EggClockFace { GtkDrawingArea parent; /* private */ }; struct _EggClockFaceClass { GtkDrawingAreaClass parent_class; }; 

There is also some boilerplate that is required in the header file for a new class. This allows all of those convienience macros that you see when using GTK+ widgets. Without further explanation, this should go at the top of clock.h:

 #define EGG_TYPE_CLOCK_FACE (egg_clock_face_get_type ()) #define EGG_CLOCK_FACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EGG_TYPE_CLOCK_FACE, EggClockFace)) #define EGG_CLOCK_FACE_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), EGG_CLOCK_FACE, EggClockFaceClass)) #define EGG_IS_CLOCK_FACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EGG_TYPE_CLOCK_FACE)) #define EGG_IS_CLOCK_FACE_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((obj), EGG_TYPE_CLOCK_FACE)) #define EGG_CLOCK_FACE_GET_CLASS (G_TYPE_INSTANCE_GET_CLASS ((obj), EGG_TYPE_CLOCK_FACE, EggClockFaceClass)) 

When the class is initialised the function egg_clock_face_class_init() is going to be called. This gives us a chance to set certain class wide functions and properties in our new class. Since we’re doing drawing, we’re going to need to override the parent’s expose handler. So in clock.c:

 static void egg_clock_face_class_init (EggClockFaceClass *class) { GtkWidgetClass *widget_class; widget_class = GTK_WIDGET_CLASS (class); widget_class->expose_event = egg_clock_face_expose; } 

Later on we can also use the class_init function to add a struct of private variables to each instance using g_type_class_add_private().

When someone creates a new EggClockFace, egg_clock_face_init() will be called. We don’t need to worry about constructing the GtkWidget or allocating any memory, that has already been handled for us. For the moment, let’s just keep the function empty.

 static void egg_clock_face_init (EggClockFace *clock) { } 

You’ll notice that all of these functions are static. You should remember that these functions are all internal to how the object works and aren’t meant to be exposed in a public API.

We do need a way to create an object though, so let’s add egg_clock_face_new().

 GtkWidget * egg_clock_face_new (void) { return g_object_new (EGG_TYPE_CLOCK_FACE, NULL); } 

As you can see, this function is simply a wrapper for convienience.

Finally, to make it compile, we’re going to need to define our expose handler:

 static gboolean egg_clock_face_expose (GtkWidget *clock, GdkEventExpose *event) { return FALSE; } 

You’ll also want to write a main() function so you can see something. This is what I have in main.c:

 int main (int argc, char **argv) { GtkWidget *window; GtkWidget *clock; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); clock = egg_clock_face_new (); gtk_container_add (GTK_CONTAINER (window), clock); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_show_all (window); gtk_main (); } 

So, if you’ve made it this far. You should have files that look like clock-ex1.c, clock.h, and main.c.

You can compile it with the simple line:

 gcc -o clock `pkg-config --cflags --libs gtk+-2.0` clock.h clock-ex1.c main.c 

And it should look something like this:

Pretty neat, huh? Well… maybe not yet. Now we need to draw something in there!

Step 2. Drawing with Cairo

When things need drawing in GTK+ an “expose-event” will be emitted. As you’ll recall from Step 1, we put the stub for an expose handler in our code. When an expose event occurs, GTK+ will also give us other information, including the area of the widget that we need to redraw. All of this information is contained within the GdkEventExpose struct.

In order to do drawing with Cairo we need a Cairo context (called a cairo_t). We can get a cairo_t for a GdkWindow (this is what you’re drawing into). You should be aware that a GdkWindow is not like a GtkWindow and that all sorts of widgets have one or more GdkWindows inside them for doing drawing. If you can’t keep track of all the names, don’t worry too much, you’ll get the hang of it eventually.

You can access the GdkWindow of most widgets (such as a GtkDrawingArea) by accessing the window member of the widget struct, eg. widget->window. So to get our cairo_t we can extend our expose stub to look like this:

 static gboolean egg_clock_face_expose (GtkWidget *clock, GdkEventExpose *event) { cairo_t *cr; /* get a cairo_t */ cr = gdk_cairo_create (clock->window); draw (clock, cr); cairo_destroy (cr); return FALSE; } 

This will redraw the entire widget on each expose event. To make things faster we might like to set a clip region.

 static gboolean egg_clock_face_expose (GtkWidget *clock, GdkEventExpose *event) { cairo_t *cr; /* get a cairo_t */ cr = gdk_cairo_create (clock->window); /* set a clip region for the expose event */ cairo_rectangle (cr, event->area.x, event->area.y, event->area.width, event->area.height); cairo_clip (cr); draw (clock, cr); cairo_destroy (cr); return FALSE; } 

Now we actually need to draw something. Drawing instructions in Cairo work by describing paths and then stroking them. Think of it like tracing your design out with a pencil and then inking it in with a pen. You can choose a variety of different pens with different nibs and colors, but each stroking is done with a particular pen. You can also do other actions like filling a path with a solid color as well as being able to preserve a path so that you can stroke around it after you fill it.

Firstly, we’re trying to draw a clock face, so we need to do a little bit of simple geometry. The size of our canvas is stored in the widget struct as the member ‘allocation’. Therefore, we can find out the center of our canvas (x, y) pretty easily:

 double x, y; x = clock->allocation.x + clock->allocation.width / 2; y = clock->allocation.y + clock->allocation.height / 2; 

Since we want to draw a circle, we can work out the biggest radius that we’re
able to draw based on the size of our canvas:

 double radius; radius = MIN (clock->allocation.width / 2, clock->allocation.height / 2) - 5; 

To draw the clock face we want to describe an arc centered at (x, y) and sweep
between 0 and 2? radians.

 cairo_arc (cr, x, y, radius, 0, 2 * M_PI); 

We then want to fill that circle with white and then stroke around that white circle with a black outline.

 cairo_set_source_rgb (cr, 1, 1, 1); cairo_fill_preserve (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_stroke (cr); 

It will look rather like this:

We can also add a marker for each hour on the clock face. Using a bit of geometry again, we know that we need to divide 2? into 12 pieces, which means that each line is ?/6 radians apart.

We want to draw a line from just inside the circle to the edge of the circle. We can define the path for a line using cairo_move_to() and cairo_line_to().

 for (i = 0; i < 12; i++) { int inset; inset = 0.1 * radius; cairo_move_to (cr, x + (radius - inset) * cos (i * M_PI / 6), y + (radius - inset) * sin (i * M_PI / 6)); cairo_line_to (cr, x + radius * cos (i * M_PI / 6), y + radius * sin (i * M_PI / 6)); cairo_stroke (cr); } 

We could also mark the tick for every quarter more strongly than the hour marks.

 for (i = 0; i < 12; i++) { int inset; cairo_save (cr); /* save pen size to stack */ if (i % 3 == 0) { inset = 0.2 * radius; } else { inset = 0.1 * radius; cairo_set_line_width (cr, 0.5 * cairo_get_line_width (cr)); } cairo_move_to (cr, x + (radius - inset) * cos (i * M_PI / 6), y + (radius - inset) * sin (i * M_PI / 6)); cairo_line_to (cr, x + radius * cos (i * M_PI / 6), y + radius * sin (i * M_PI / 6)); cairo_stroke (cr); cairo_restore (cr); /* recover pen size from stack */ } 

You can see here that we’ve used two new functions cario_save() and cairo_restore(). These functions allow us to manipulate a stack of cairo states. To save our old values for the pen width, we simply put it on the stack. We can then modify that width and stroke some paths. Finally we can simply restore the old state again once we’re ready. This is an easy way to not have to keep track of your existing drawing defaults throughout each stage of a drawing operation.

Your C file should look like clock-ex3.c with the new drawing instructions.

If you compile it with

 gcc -o clock `pkg-config --cflags --libs gtk+-2.0` clock.h clock-ex3.c main.c 

you will get a blank clock face:

So we’ve covered the basics of drawing something on your canvas and making sure that GTK+ redraws it when it is exposed. Next time we’ll look at how to extend your widget with an API so that we can actually start drawing content on it and implementing signals so that we can receive updated information.

If you want to learn more about Cairo and the Cairo drawing API, see their website: http://www.cairographics.org/

Discuss this story with other readers on the GNOME forums.

Advertisements

Get to Know GnomeMeeting

Video telephony over the Internet is not common place for Joe User yet, but its importance is growing. Julien Gilli takes a closer look at GnomeMeeting and talks to its main creator and developer, Damien Sandras.

 

Some background information

A little bit of GnomeMeeting history

GnomeMeeting is the telephony and videoconferencing solution for the GNOME desktop. It was originally named after NetMeeting, the piece of software developed by Microsoft that was the first to provide voice and video communications for end users.

GnomeMeeting was originally Damien Sandras’ final year project. Damien is still leading the project actively together with several other developers. It was first integrated to the GNOME desktop for its 2.4 revision in September 2003 and has since been one its official components. The 1.0 version came out in March 2004. The last stable version, numbered 1.2.2 was released with the GNOME 2.12 desktop on September 7th and the next big milestone will be 2.0.

Damien Sandras, GnomeMeeting’s main developer and creator, has been kind enough to answer our questions. This article is a review of where GnomeMeeting stands today, compared to other solutions, as well as an insight on what exciting new features to expect from the future releases.

The competitors

Many other very high quality software phones have entered the game since the birth of GnomeMeeting. Skype was born in April 2003 and has already more than fifty million active users. Gizmo and Google Talk are other very active challengers. The features list of all these softphones is pretty impressive. For example, Gizmo has a map it functionality that allows callers to locate the other end of the line on a map, Skype has built-in file transfer, encryption of communications and text instant messaging.

All these pieces of software work correctly with the GNOME desktop and are, more generally, well supported on GNU/Linux. For instance, Skype has been integrated to Mandriva 2006, Xandros and is available as easily installable binary packages for the most popular distributions like Fedora and Debian.

Asking Damien how his solution compares to the others, he emphasizes the fact that “GnomeMeeting is old and mature”. He also points out that “It was already existing back in 2001 when Voice over IP was not popular at all yet.”.

Regarding Skype, which is the most popular at the moment, he says that “the main advantage of GnomeMeeting is that [we] are not locking [our] users into a proprietary protocol”. In the same effort to provide as much freedom as possible for the end user, he also notes that ”[we] are not forcing [our] users to use a specific commercial service for PC-To-Phone and Phone-To-PC calls: they have the freedom to choose.”.

One thing that may become more of a concern in the future is the guaranteed confidentiality and integrity of the communications between users. On this point, Damien notes that ”[end users] can keep the control over their conversations and they know what happens to their data”.

So, GnomeMeeting being free software, its open source code brings some real advantages over Skype. But, in Damien’s opinion, it also wins on features and performance, like latency. “unlike Skype, the connection is directly established between the two users, which means less latency when both endpoints are behind a NAT. Latency is not a big problem when you are transmitting and receiving only audio like Skype, but when you add video, things are getting worse.”, says Damien.

GnomeMeeting’s strong points

In Damien’s opinion, GnomeMeeting has several strong points. For one thing, “it supports more protocols”. Indeed, GnomeMeeting supports H.323 and will soon support SIP (more on this in the next section) whereas many other softphones only support one protocol, which is often SIP.

He also points out that ”[GnomeMeeting is] not trying to influence [its] users to use a specific commercial service”. Indeed, anyone can connect to any VoIP service provider using GnomeMeeting, provided the given service supports SIP or H323.

Finally, ”[any commercial initiative] can decide at any moment to stop the development because the profits are not important enough”, says Damien.

GnomeMeeting’s new features

The next release of GnomeMeeting will bring some interesting new features that will make it even more competitive regarding the other solutions mentioned above.

SIP support

“The current SIP support is nearly complete compared to our initial objectives. We support all features that were already supported for H.323 in our 1.2.x release and more”, says Damien. Below is a list of features already supported :

  • SIP over UDP
  • Call Hold
  • Call Transfer
  • Call Forwarding
  • Message Waiting Indications when you receive a voice e-mail
  • Instant Messages
  • Assisted NAT traversal thanks to STUN or IP Translation
  • DTMF’s
  • Multiple simultaneous registrations to several providers
  • Audio and Video

The GnomeMeeting.net platform

One thing that confirms their desire to provide freedom of choice to the end user, is that Damien and his team plan to “offer SIP addresses to all of [their] users (e.g.: sip:damien@gnomemeeting.net) as well as voice mail redirection when a user is away or offline, conference rooms, LDAP support to look for friends, and more”. This set of services is called the GnomeMeeting.net platform. “a BETA sponsored by OVH is already available.” says Damien.

Other enhancements and features

Several other enhancements are planned for the next releases to come. Two of them are Avahi and D-BUS support.

The former, contributed by Sebastien Estienne, makes GnomeMeeting into a Rendez-Vous compliant application, which means that it will be able to guess which services are available, at anytime.

The latter has been contributed by Julien Puydt and allows “other programs to remotely control [GnomeMeeting] or get information about the current status of a call.”, which is a real improvement over the command line way of doing things in the past. This could mean much more integration to the GNOME desktop in the near future. We’ll move on to that later.

Finally, a Windows port has also been worked on by Julien Puydt. We can see it working through a VNC connection here, on the bottom right. It could bring a lot of users to GnomeMeeting.

Corporate support

Even if one of GnomeMeeting’s strong points is being vendor neutral, it doesn’t mean that it has to be hostile to commercial service providers. Asked which service providers can be used by GnomeMeeting, Damien answered that “as GnomeMeeting is SIP and H.323 compliant, any SIP or H.323 provider can be used to contact real phones all over the world”.

Regarding the GnomeMeeting.net platform, Damien says that “GnomeMeeting will not be restricted to GnomeMeeting.NET and other GnomeMeeting users”. He also mentions a clever trick that illustrates the benefits that openness brings to GnomeMeeting. Indeed, “any user of Asterisk can configure GnomeMeeting to work with [their] home IPBX and [make] phone calls using a softphone instead of a traditional phone”, says Damien.

Another interesting feature of GnomeMeeting is that “you can register simultaneously to several providers at the same time and use the one that is the best suited for each task when dialing out”.

Regarding partnerships between GnomeMeeting and VoIP service providers, Damien insists on ”[offering] the most services possible to [our] users.”. He thinks that “it is important to stay independent from any vendor, even though [we] can recommend a few ones if [we] know that they are serious.”. They “are thus open to any proposition”, declares Damien.

Integration to the GNOME desktop

One of the differentiating factors of GnomeMeeting is that it has “GNOME” in its name. To the end user, it means that using GnomeMeeting with GNOME feels natural. Moreover, for some GNOME users, GnomeMeeting is the main reason behind a move to the GNOME desktop. Indeed, Damien knows “of users or universities that have chosen GNOME as desktop because GnomeMeeting was working well with it”.

A way to achieve GnomeMeeting’s integration to the desktop is clickable VoIP URIs, like sip:id@domain.com. One would expect the right application in the right state to pop up after having clicked such a URI. However, Damien says that “GNOME should provide the tools so that it is easy to do it, and nearly automagical once an URI has been added in the URL handlers.”. Regarding clickable URIs, “they are providing the tools so that it works when [GNOME developers] are ready to integrate it.”, says Damien. The D-BUS support above mentioned is one such tool.

Although Damien did not mention it, in the future a project as Telepathy, if it manages to be successful, could be the solution to the integration of IM, voice and video over IP applications for GNOME. However, it’s still too early to tell, since the project started only two months ago.

Technical details

Since its early days, GnomeMeeting has been based on the OpenH323 library. Its initial developers had started its successor, OPAL, which was designed from the ground up to support several different protocols and is now used by GnomeMeeting instead of OpenH323.

Regarding OPAL’s SIP support, “There was some SIP support and i have added all the features that were required for GnomeMeeting”, declares Damien. Surprisingly, he is “spending most of [his] time on OPAL and not on GnomeMeeting, which is fun too”.

One may wonder how well the SIP and H323 protocol fit together in the same application. Again, Damien and his team seem to have focused on simplicity : “when doing an outgoing call, the user has to double-click on a contact in his address book, or enter the URI where the remote user is reachable. When receiving an incoming call, the user has nothing to do except accepting or rejecting it. We request the minimum of interaction and knowledge from our users”, says Damien. To give an analogy that may be familiar to most of us, Damien says that “the behavior is similar to the way a browser works with http/https/ftp URIs”.

Roadmap

Asked for a 2.0 release date, he answered that “users can expect the 2.00 release to be available early in January 2006 together with the GnomeMeeting.NET platform”. He also added that, while adding new features, “the purpose of the 2.00 release is to keep the same features [as] in the 1.x releases, but for several protocols, namely H.323 and SIP.”

For the 2.2 release, which has no release date yet, ”[we] also plan to add SIP presence support, and support for multiple lines as GnomeMeeting is currently limited to 1 line”, says Damien.

Conclusion

Damien and his team have made a strong point on being as open as possible and respectful of the standards on all aspects of their project, socialy and technically.

Because their project is one of the more mature ones now, they are able to provide a large list of features. “Our interest is to provide a complete solution, usable for simple video chat, but also as a complex softphone able to replace the most complex phone used with a PABX.”, says Damien.

It seems that future releases will bring a lot of interesting new features, like fairly complete SIP support and a Windows port.

The new GnomeMeeting.net platform, providing SIP addresses for everyone, may also extend the GnomeMeeting’s user base in the future.

Some new developers have contributed significant enhancements, which shows the project is healthy and growing. The D-BUS support will bring more integration to the GNOME desktop and remoting capabilities, while Avahi support provides automatic discovery of available services. One might expect the list of active contributors, and consequently features, to grow even more in the future.

There are a lot of competitors in the VoIP arena, and there are more every day. However GnomeMeeting seems to have strong selling points and to have no reason to fear from the competition.

This article ends with Damien’s words: “Think Free. Think Open. Never forget why you are using Free Software and be consistent with yourself”.

Useful Resources

GnomeMeeting’s Web Site
GnomeMeeting.net Platform
GnomeMeeting’s last GUADEC conferences slides

Discuss this story with other readers on the GNOME forums.

Macedonia Deploys 5,000 GNOME Desktops in Public Schools

When the Republic of Macedonia decided to deploy Linux in 468 schools and 182 computer labs nationwide, they chose GNOME on an Ubuntu distribution. Arangel Angov met with Darko Arsov, Technology Integration Manager at the Education Development Center, to find out more about their reasons for using GNOME.

The Republic of Macedonia is a small country in Southern Europe with a population of around 2 million. Internet penetration is only around 5% and software piracy is rampant. Also, the government does not play any major role in the development of the ICT (Information and Communication Technologies) and a private sector is dominated by Microsoft technologies.

Given the circumstances, one would not expect any free software related stories to make the headlines. Yet the presence of a small volunteer organization by the name Free Software Macedonia is making a big difference in this small country.

At the time of writing this article, all major Free Open Source Software (FOSS) projects have either been translated or were close to being translated in Macedonian language. Tools such as spell checkers are also under development. Although, resources are scarce, dedication and enthusiasm has kept these projects going.

This particular write-up is about implementation of GNOME.

It was in early August that a friend of mine told me about a project involving mass deployment of FOSS in public schools throughout the Republic of Macedonia.

After a little research, I found out that the project involved deployment of Ubuntu Linux, which comes with GNOME as a default desktop environment. About 5000 PC’s in all of the public schools in Macedonia, both primary and secondary, got Ubuntu and GNOME deployed on them.

As a part of a joined project called “E-School.MK”, US Agency for International Development (USAID), Education Development Center (EDC) and the Macedonian Ministry of Education and Science (MoES) decided to install Ubuntu Linux in all the 468 schools and some 182 computer labs all over the country.

Later on with the help of a GNOME user that worked at EDC (the organization responsible for the E-School.MK project) as a network administrator, I got in touch with Darko Arsov and arranged a one-on-one interview. Darko was working on this project since its inception. He is the Technology Integration Manager at EDC. In the interview he explained the decision to choose Ubuntu and GNOME and also their future plans and activities that are part of the ongoing project.

We met at a local cafe just opposite of the EDC headquarters in the west side of the capital Skopje. I started the interview by asking Darko what made them consider deploying Ubuntu and GNOME in the first place.

Darko: After a few meetings and some research, Ubuntu just came up as first on the list. The main factor that influenced our choice was the interoperability of Ubuntu with other operating systems. GNOME is really all about simplicity and usability. The simple and easy-to-use GNOME UI had a great influence on the final decision and to be honest we’re quite happy with our choice thus far.

Q. When was the project started and how long until it’s complete?

Darko: The planning started in early 2004 and the actual implementation began in June during the summer holidays. In about four months we’ve managed to clone 5000 PC’s and install high speed WiFi Internet in 460 schools.

Q. How do you like the Ubuntu and GNOME 6-month release cycle?

Darko: Well the 6-month release cycle has advantages, because it allows the software to be stable and well tested before it gets to the hands of the end users. Also, this gives some nice planning advantages because you know when you can expect a new version and you know that twice a year your software gets updated with new features.

Q. Are you aware of the existence of free software projects such as the education applications at gnomefiles.org and/or EDUbuntu, and do you plan to introduce them as a part of your project?

Darko: We heard about EDUbuntu – the educational version of Ubuntu and we are waiting for the official release to be released before we consider if this project satisfies the needs of the Macedonian educational system. I think that there is a strong possibility of implementing something like this in the near future. We’re also interested in localizing some of the educational applications for GNOME and implement them in the existing environment.

Q. Since the PC’s are running GNOME 2.8 on Ubuntu Warty, do you plan to upgrade them to a newer version of GNOME, and why did you install Warty in the first place?

Darko: Of course, one of our main project goals is sustainability and that’s why we’ll even encourage teachers to keep up with releases and upgrade regularly. Since GNOME 2.12 is fully translated into Macedonian we would most certainly upgrade all the PC’s as soon as possible. When we started planning the project, somewhere at the beginning of 2004, Warty was still the stable release of Ubuntu and because we had it tested we decided to go with it all the way. But, as I said previously, we’ll make sure that the PC’s are upgraded regularly.

Q. Do you plan to support the use of free software such as GNOME in the near future. Could you tell us something more about this?

Darko: Everything we did regarding this project was in collaboration with the MoES and we hope that the MoES will continue supporting the use of free and open source software in the educational institutions throughout the country. We are and will be supporting these kinds of projects because we consider free software to be the best tool that makes it possible for students to learn how things work in a certain software making them understand the process of creating a program far more easily. I would also like to mention that we’ve set up 82 wireless hot spots in these labs both in rural and urban areas around the country. We hope that the fast Internet connection will allow both students and teachers to learn more about the software they’re using, how to add software, play with the code and participate in programming projects. We definitely support and encourage both students and teachers to experiment in their newly deployed environments so they can get to know the desktop environment and the OS as a whole.

As a part of this project through seminars and some training we’ll also be providing some 10,000 teachers from both primary and secondary schools, the basic skills for working with GNU/Linux and GNOME. At the end, we’ll be analyzing the short and long-term effects of the project.

Q. Anything else?

Darko: 🙂 We’re also working on a web portal intended for students. The portal will definitely be an open source project where students could open accounts, upload their code, join up in teams to work together on software projects, share experiences and above all learn things from which they will all benefit in the future.

As a big supporter and user of GNOME, I hope that in the long run this project will be successful. I hope that it’ll help in transforming the new generation of coders into new GNOME developers that will continue to create, maintain, document and localize quality free software for generations to come.

Discuss this story with other readers on the GNOME forums.