Kinds of Widget

The term "widget" is really very broad, since it encompasses any object that implements the GtkWidget interface. There are many ways to classify widgets:

• Containers are widgets that store other widgets inside, such as the boxes and tables described in the chapter called GTK+ Basics. As the chapter called GTK+ Basics discussed, containers can be subdivided into those that add functionality to a single child (GtkButton, GtkFrame, GtkEventBox, etc.), and those that manage layout for multiple children (GtkBox, GtkTable, etc.). Container widgets are harder to implement than "plain" widgets because the GtkContainer interface must be implemented in addition to the GtkWidget interface.

• Composite widgets are containers that already contain a useful collection of child widgets in a nice package. For example, the GtkFileSelection widget is a subclass of GtkWindow that already contains a list widget to show files, dialog buttons, and so on. Widgets like this are easy to write, and are a convenient way to code applications. You could write a "MainWindow" widget for your main application window, for example, and then create a new instance of the widget whenever the user opens a new document. GnomeApp and GnomeDialog are two important composite widgets in Gnome.

• Non-container widgets can be actual controls (buttons, scroll bars, etc.), information displays (GtkLabel), or decorative flourishes (GtkSeparator, for example). As the chapter called GTK+ Basics briefly mentioned, there are two major ways to implement widgets: most widgets (those that need to receive events or draw their own background) have an associated GdkWindow; "no window" widgets draw on their parent container. Widgets without windows are implemented slightly differently. All containers have a GdkWindow (since widgets without one might need to draw on it, among other reasons).

This chapter presents several widgets as examples, including a GtkEv widget written especially for this book, GtkVBox from GTK+, and GnomeAppBar from libgnomeui.

What a Widget Does

A minimal widget implements the following (though GtkWidget's default implementation may be sufficient in many cases):

• Creation and destruction; this means the usual GtkObject boilerplate (instance and class initializers, shutdown, destroy and finalize methods). See the chapter called The GTK+ Object and Type System, especially the section called Object and Class Structures in the chapter called The GTK+ Object and Type System and the section called Object Finalization in the chapter called The GTK+ Object and Type System. Also see the section called Widget Life Cycle in the chapter called GTK+ Basics.

• The realize/map/unmap/unrealize cycle discussed in the section called Realizing, Mapping, and Showing in the chapter called GTK+ Basics. Widgets must be able to create and uncreate their associated X resources any number of times, and they must be able to show and hide themselves any number of times.

• Geometry negotiation, discussed in the section called Size Allocation in the chapter called GTK+ Basics. Your widget must respond to size requests, and honor size allocations.

• Drawing; widgets must be able to draw themselves on the screen. For container widgets, the widget itself may be invisible but it must ensure child widgets are drawn.

• The widget's unique functionality. Typically this means implementing handlers for some of the widget's event signals.