Graphical Libraries in Gnome

• glib : set of functions (memory allocation, timers, I/O) used by many other libraries. It handles the main loop for multiple resources.
• X : low-level function to control the display on Unix-Linux machines
• GDK : function that simplify the access to the X library.
• GTK+ : the GIMP Toolkit. Organizes the functions from GDK into objects of type widgets with standard interfaces.
• GNOME : specialized extension of GTK+. Developed for the GNOME desktop environment. Other applications can use it.

Drawable Area

• A gtk widget that can be used for any kind of application with dynamically changing content.
• Can contain either an image or text.
• It doesn't automatically update itself. You have to connect any kind of signal to a function that can draw its content.

• A matrix of pixels that resides in memory and can be displayed on many different widgets.
• The content of the pixmap can come from a file or can be drawn with the same graphic functions used to draw an area.
• A pixmap can be also specified by hand as an array of a some type.
• Gnome has a number of standard constant pixmaps that can be used by any application.

• The pixmap can be displayed on a drawable area much faster than redrawing the area.
• Any portion of the pixmap can be displayed at any location of the area.
• The pixmap can be drawn once and redisplayed any number of times.
• In general redrawing the pixmap is done on special occasions. Redisplaying it on the drawing area happens for any event.
• Especially useful for animation.

Color in Gnome

• Base type: GdkColor with fields red, green, blue, and pixel (not explicitly used).
• The color can only be used within a colormap (GdkColormap).

colormap = gdk_colormap_get_system();
• Once you define a color, you must allocate it in the colormap, which either inserts it if possible, or finds the closest existing color.

gdk_color_alloc(colormap, &color);

• To set a custom color for a widget, you need a graphical context (GdkGC).
• You can associate the graphical context with the window of any widget:

gc = gdk_gc_new(widget->window);
• Then you can set the foreground or background color of that widget to your color, and anything you draw in it will use the foreground color:

gdk_gc_set_foreground(gc, &color);
gdk_draw_rectangle(widget->window,gc,…);

• Created from inside a callback function, usually to display information or accept data from the user.

gnome_ok_dialog(“I told you so”);
• When closed, a dialog may return some data depending on its nature. This data is usually the first parameter of the callback function for the dialog itself.

#include <gnome.h>
void cbfunction(gint reply, gpointer data)
{
  if (reply == GNOME_YES)
    gprint(“the answer is yes\n”);
  else
    gprint(“the answer is no\n”);
}
int main(int argc, char **argv) {
  gnome_init(“questiondialog”, “1.0”, argc, argv);
  gnome_question_dialog(“Do you want to quit?”,
            (GnomeReplyCallback)cbfunction, NULL);
  gtk_main();
  exit(0);
}

struct _GdkColor {
  gulong pixel;
  gushort red;
  gushort green;
  gushort blue;
}

gdk_pixmap_new (GdkDrawable *drawable, gint width, gint height, gint depth);
• drawable :
• width :  The width of the new pixmap in pixels.
• height :  The height of the new pixmap in pixels.
• depth :  The depth (number of bits per pixel) of the new pixmap. If -1, and window is not NULL, the depth of the new pixmap will be equal to that of window.

struct GdkColormap
struct GdkColormap { GObject parent_instance; gint size;
                     GdkColor *colors; };
• The colormap structure contains the following public fields.
•         GObject parent_instance
•         gint size
• For pseudo-color colormaps, the number of colors in the colormap.
•         GdkColor *colors
• An array containing the current values in the colormap. This can be used to map from pixel values back to RGB values. This is only meaningful for pseudo-color colormaps.