1 <!doctype linuxdoc system>
3 <!-- This is the tutorial marked up in SGML
4 (just to show how to write a comment)
9 <author>Ian Main <tt><htmlurl url="mailto:imain@gtk.org"
10 name="<imain@gtk.org>"></tt>,
11 Tony Gale <tt><htmlurl url="mailto:gale@gtk.org"
12 name="<gale@gtk.org>"></tt>
15 <!-- ***************************************************************** -->
17 <!-- ***************************************************************** -->
19 GTK (GIMP Toolkit) was originally developed as a toolkit for the GIMP
20 (General Image Manipulation Program). GTK is built on top of GDK (GIMP
21 Drawing Kit) which is basically wrapper around the Xlib functions. It's
22 called the GIMP toolkit because it was original written for developing
23 the GIMP, but has now been used in several free software projects. The
26 <item> Peter Mattis <tt><htmlurl url="mailto:petm@xcf.berkeley.edu"
27 name="petm@xcf.berkeley.edu"></tt>
28 <item> Spencer Kimball <tt><htmlurl url="mailto:spencer@xcf.berkeley.edu"
29 name="spencer@xcf.berkeley.edu"></tt>
30 <item> Josh MacDonald <tt><htmlurl url="mailto:jmacd@xcf.berkeley.edu"
31 name="jmacd@xcf.berkeley.edu"></tt>
35 GTK is essentially an object oriented application programmers interface (API).
36 Although written completely in
37 C, it is implemented using the idea of classes and callback functions
38 (pointers to functions).
40 There is also a third component called glib which contains a few
41 replacements for some standard calls, as well as some additional functions
42 for handling linked lists etc. The replacement functions are used to
43 increase GTK's portability, as some of the functions implemented
44 here are not available or are nonstandard on other unicies such as
45 g_strerror(). Some also contain enhancements to the libc versions, such as
46 g_malloc that has enhanced debugging utilities.
48 This tutorial is an attempt to document as much as possible of GTK, it is by
49 no means complete. This
50 tutorial assumes a good understanding of C, and how to create C programs.
51 It would be a great benefit for the reader to have previous X programming
52 experience, but it shouldn't be necessary. If you are learning GTK as your
53 first widget set, please comment on how you found this tutorial, and what
55 Note that there is also a C++ API for GTK (GTK--) in the works, so if you
56 prefer to use C++, you should look into this instead. There's also an
57 Objective C wrapper, and guile bindings available, but I don't follow these.
59 I would very much like to hear any problems you have learning GTK from this
60 document, and would appreciate input as to how it may be improved.
62 <!-- ***************************************************************** -->
64 <!-- ***************************************************************** -->
67 The first thing to do of course, is download the GTK source and install
68 it. You can always get the latest version from ftp.gtk.org in /pub/gtk.
69 You can also view other sources of GTK information on http://www.gtk.org/
70 <htmlurl url="http://www.gtk.org/" name="http://www.gtk.org/">.
71 GTK uses GNU autoconf for
72 configuration. Once untar'd, type ./configure --help to see a list of options.
74 To begin our introduction to GTK, we'll start with the simplest program
75 possible. This program will
76 create a 200x200 pixel window and has no way of exiting except to be
77 killed using the shell.
82 int main (int argc, char *argv[])
86 gtk_init (&argc, &argv);
88 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
89 gtk_widget_show (window);
97 All programs will of course include the gtk/gtk.h which declares the
98 variables, functions, structures etc. that will be used in your GTK
104 gtk_init (&argc, &argv);
107 calls the function gtk_init(gint *argc, gchar ***argv) which will be
108 called in all GTK applications. This sets up a few things for us such
109 as the default visual and color map and then proceeds to call
110 gdk_init(gint *argc, gchar ***argv). This function initializes the
111 library for use, sets up default signal handlers, and checks the
112 arguments passed to your application on the command line, looking for one
116 <item> <tt/--display/
117 <item> <tt/--debug-level/
118 <item> <tt/--no-xshm/
120 <item> <tt/--show-events/
121 <item> <tt/--no-show-events/
124 It removes these from the argument list, leaving anything it does
125 not recognize for your application to parse or ignore. This creates a set
126 of standard arguments accepted by all GTK applications.
128 The next two lines of code create and display a window.
131 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
132 gtk_widget_show (window);
135 The GTK_WINDOW_TOPLEVEL argument specifies that we want the window to
136 undergo window manager decoration and placement. Rather than create a
137 window of 0x0 size, a window without children is set to 200x200 by default
138 so you can still manipulate it.
140 The gtk_widget_show() function, lets GTK know that we are done setting the
141 attributes of this widget, and it can display it.
143 The last line enters the GTK main processing loop.
149 gtk_main() is another call you will see in every GTK application. When
150 control reaches this point, GTK will sleep waiting for X events (such as
151 button or key presses), timeouts, or file IO notifications to occur.
152 In our simple example however, events are ignored.
154 <!-- ----------------------------------------------------------------- -->
155 <sect1>Hello World in GTK
157 OK, now for a program with a widget (a button). It's the classic hello
165 /* this is a callback function. the data arguments are ignored in this example..
166 * More on callbacks below. */
167 void hello (GtkWidget *widget, gpointer data)
169 g_print ("Hello World\n");
172 gint delete_event(GtkWidget *widget, gpointer data)
174 g_print ("delete event occured\n");
175 /* if you return FALSE in the "delete_event" signal handler,
176 * GTK will emit the "destroy" signal. Returning TRUE means
177 * you don't want the window to be destroyed.
178 * This is useful for popping up 'are you sure you want to quit ?'
181 /* Change TRUE to FALSE and the main window will be destroyed with
182 * a "delete_event". */
187 /* another callback */
188 void destroy (GtkWidget *widget, gpointer data)
193 int main (int argc, char *argv[])
195 /* GtkWidget is the storage type for widgets */
199 /* this is called in all GTK applications. arguments are parsed from
200 * the command line and are returned to the application. */
201 gtk_init (&argc, &argv);
203 /* create a new window */
204 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
206 /* when the window is given the "delete_event" signal (this is given
207 * by the window manager (usually the 'close' option, or on the
208 * titlebar), we ask it to call the delete_event () function
209 * as defined above. The data passed to the callback
210 * function is NULL and is ignored in the callback. */
211 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
212 GTK_SIGNAL_FUNC (delete_event), NULL);
214 /* here we connect the "destroy" event to a signal handler.
215 * This event occurs when we call gtk_widget_destroy() on the window,
216 * or if we return 'FALSE' in the "delete_event" callback. */
217 gtk_signal_connect (GTK_OBJECT (window), "destroy",
218 GTK_SIGNAL_FUNC (destroy), NULL);
220 /* sets the border width of the window. */
221 gtk_container_border_width (GTK_CONTAINER (window), 10);
223 /* creates a new button with the label "Hello World". */
224 button = gtk_button_new_with_label ("Hello World");
226 /* When the button receives the "clicked" signal, it will call the
227 * function hello() passing it NULL as it's argument. The hello() function is
229 gtk_signal_connect (GTK_OBJECT (button), "clicked",
230 GTK_SIGNAL_FUNC (hello), NULL);
232 /* This will cause the window to be destroyed by calling
233 * gtk_widget_destroy(window) when "clicked". Again, the destroy
234 * signal could come from here, or the window manager. */
235 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
236 GTK_SIGNAL_FUNC (gtk_widget_destroy),
237 GTK_OBJECT (window));
239 /* this packs the button into the window (a gtk container). */
240 gtk_container_add (GTK_CONTAINER (window), button);
242 /* the final step is to display this newly created widget... */
243 gtk_widget_show (button);
246 gtk_widget_show (window);
248 /* all GTK applications must have a gtk_main(). Control ends here
249 * and waits for an event to occur (like a key press or mouse event). */
256 <!-- ----------------------------------------------------------------- -->
257 <sect1>Compiling Hello World
262 gcc -Wall -g helloworld.c -o hello_world `gtk-config --cflags` \
267 This uses the program <tt>gtk-config</>, which comes with gtk. This
268 program 'knows' what compiler switches are needed to compile programs
269 that use gtk. <tt>gtk-config --cflags</> will output a list of include
270 directories for the compiler to look in, and <tt>gtk-config --libs</>
271 will output the list of libraries for the compiler to link with and
272 the directories to find them in.
275 The libraries that are usually linked in are:
277 <item>The GTK library (-lgtk), the widget library, based on top of GDK.
278 <item>The GDK library (-lgdk), the Xlib wrapper.
279 <item>The glib library (-lglib), containing miscellaneous functions, only
280 g_print() is used in this particular example. GTK is built on top
281 of glib so you will always require this library. See the section on
282 <ref id="sec_glib" name="glib"> for details.
283 <item>The Xlib library (-lX11) which is used by GDK.
284 <item>The Xext library (-lXext). This contains code for shared memory
285 pixmaps and other X extensions.
286 <item>The math library (-lm). This is used by GTK for various purposes.
289 <!-- ----------------------------------------------------------------- -->
290 <sect1>Theory of Signals and Callbacks
292 Before we look in detail at hello world, we'll discuss events and callbacks.
293 GTK is an event driven toolkit, which means it will sleep in
294 gtk_main until an event occurs and control is passed to the appropriate
297 This passing of control is done using the idea of "signals". When an
298 event occurs, such as the press of a mouse button, the
299 appropriate signal will be "emitted" by the widget that was pressed.
301 most of its useful work. To make a button perform an action,
302 we set up a signal handler to catch these
303 signals and call the appropriate function. This is done by using a
307 gint gtk_signal_connect (GtkObject *object,
313 Where the first argument is the widget which will be emitting the signal, and
314 the second, the name of the signal you wish to catch. The third is the function
315 you wish to be called when it is caught, and the fourth, the data you wish
316 to have passed to this function.
318 The function specified in the third argument is called a "callback
319 function", and should be of the form:
322 void callback_func(GtkWidget *widget, gpointer *callback_data);
325 Where the first argument will be a pointer to the widget that emitted the signal, and
326 the second, a pointer to the data given as the last argument to the
327 gtk_signal_connect() function as shown above.
329 Another call used in the hello world example, is:
332 gint gtk_signal_connect_object (GtkObject *object,
335 GtkObject *slot_object);
338 gtk_signal_connect_object() is the same as gtk_signal_connect() except that
339 the callback function only uses one argument, a
341 object. So when using this function to connect signals, the callback should be of
345 void callback_func (GtkObject *object);
348 Where the object is usually a widget. We usually don't setup callbacks for
349 gtk_signal_connect_object however. They are usually used
350 to call a GTK function that accept a single widget or object as an
351 argument, as is the case in our hello world example.
353 The purpose of having two functions to connect signals is simply to allow
354 the callbacks to have a different number of arguments. Many functions in
355 the GTK library accept only a single GtkWidget pointer as an argument, so you
356 want to use the gtk_signal_connect_object() for these, whereas for your
357 functions, you may need to have additional data supplied to the callbacks.
359 <!-- ----------------------------------------------------------------- -->
360 <sect1>Stepping Through Hello World
362 Now that we know the theory behind this, lets clarify by walking through
363 the example hello world program.
365 Here is the callback function that will be called when the button is
366 "clicked". We ignore both the widget and the data in this example, but it
367 is not hard to do things with them. The next example will use the data
368 argument to tell us which button was pressed.
371 void hello (GtkWidget *widget, gpointer *data)
373 g_print ("Hello World\n");
378 This callback is a bit special. The "delete_event" occurs when the
379 window manager sends this event to the application. We have a choice here
380 as to what to do about these events. We can ignore them, make some sort of
381 response, or simply quit the application.
383 The value you return in this callback lets GTK know what action to take.
384 By returning TRUE, we let it know that we don't want to have the "destroy"
385 signal emitted, keeping our application running. By returning FALSE, we
386 ask that "destroy" is emitted, which in turn will call our "destroy"
390 gint delete_event(GtkWidget *widget, gpointer data)
392 g_print ("delete event occured\n");
399 Here is another callback function which causes the program to quit by calling
400 gtk_main_quit(). This function tells GTK that it is to exit from gtk_main
401 when control is returned to it.
404 void destroy (GtkWidget *widget, gpointer *data)
411 I assume you know about the main() function... yes, as with other
412 applications, all GTK applications will also have one of these.
414 int main (int argc, char *argv[])
418 This next part, declares a pointer to a structure of type GtkWidget. These
419 are used below to create a window and a button.
425 Here is our gtk_init again. As before, this initializes the toolkit, and
426 parses the arguments found on the command line. Any argument it
427 recognizes from the command line, it removes from the list, and modifies
428 argc and argv to make it look like they never existed, allowing your
429 application to parse the remaining arguments.
431 gtk_init (&argc, &argv);
434 Create a new window. This is fairly straight forward. Memory is allocated
435 for the GtkWidget *window structure so it now points to a valid structure.
436 It sets up a new window, but it is not displayed until below where we call
437 gtk_widget_show(window) near the end of our program.
439 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
442 Here is an example of connecting a signal handler to an object, in this case, the
443 window. Here, the "destroy" signal is caught. This is emitted when we use
444 the window manager to kill the window (and we return TRUE in the
445 "delete_event" handler), or when we use the
446 gtk_widget_destroy() call passing in the window widget as the object to
447 destroy. By setting this up, we handle both cases with a single call.
448 Here, it just calls the destroy() function defined above with a NULL
449 argument, which quits GTK for us.
451 The GTK_OBJECT and GTK_SIGNAL_FUNC are macros that perform type casting and
452 checking for us, as well as aid the readability of the code.
454 gtk_signal_connect (GTK_OBJECT (window), "destroy",
455 GTK_SIGNAL_FUNC (destroy), NULL);
458 This next function is used to set an attribute of a container object.
459 This just sets the window
460 so it has a blank area along the inside of it 10 pixels wide where no
461 widgets will go. There are other similar functions which we will look at
463 <ref id="sec_setting_widget_attributes" name="Setting Widget Attributes">
465 And again, GTK_CONTAINER is a macro to perform type casting.
467 gtk_container_border_width (GTK_CONTAINER (window), 10);
470 This call creates a new button. It allocates space for a new GtkWidget
471 structure in memory, initializes it, and makes the button pointer point to
472 it. It will have the label "Hello World" on it when displayed.
474 button = gtk_button_new_with_label ("Hello World");
477 Here, we take this button, and make it do something useful. We attach a
478 signal handler to it so when it emits the "clicked" signal, our hello()
479 function is called. The data is ignored, so we simply pass in NULL to the
480 hello() callback function. Obviously, the "clicked" signal is emitted when
481 we click the button with our mouse pointer.
484 gtk_signal_connect (GTK_OBJECT (button), "clicked",
485 GTK_SIGNAL_FUNC (hello), NULL);
488 We are also going to use this button to exit our program. This will
489 illustrate how the "destroy"
490 signal may come from either the window manager, or our program. When the
491 button is "clicked", same as above, it calls the first hello() callback function,
492 and then this one in the order they are set up. You may have as many
493 callback function as you need, and all will be executed in the order you
494 connected them. Because the gtk_widget_destroy() function accepts only a
495 GtkWidget *widget as an argument, we use the gtk_signal_connect_object()
496 function here instead of straight gtk_signal_connect().
499 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
500 GTK_SIGNAL_FUNC (gtk_widget_destroy),
501 GTK_OBJECT (window));
504 This is a packing call, which will be explained in depth later on. But it
505 is fairly easy to understand. It simply tells GTK that the button is to be
506 placed in the window where it will be displayed.
508 gtk_container_add (GTK_CONTAINER (window), button);
511 Now that we have everything setup the way we want it to be. With all the
512 signal handlers in place, and the button placed in the window where it
513 should be, we ask GTK to "show" the widgets on the screen. The window
514 widget is shown last so the whole window will pop up at once rather than
515 seeing the window pop up, and then the button form inside of it. Although
516 with such simple example, you'd never notice.
518 gtk_widget_show (button);
520 gtk_widget_show (window);
523 And of course, we call gtk_main() which waits for events to come from the X
524 server and will call on the widgets to emit signals when these events come.
528 And the final return. Control returns here after gtk_quit() is called.
533 Now, when we click the mouse button on a GTK button, the
534 widget emits a "clicked" signal. In order for us to use this information, our
535 program sets up a signal handler to catch that signal, which dispatches the function
536 of our choice. In our example, when the button we created is "clicked", the
537 hello() function is called with a NULL
538 argument, and then the next handler for this signal is called. This calls
539 the gtk_widget_destroy() function, passing it the window widget as it's
540 argument, destroying the window widget. This causes the window to emit the
541 "destroy" signal, which is
542 caught, and calls our destroy() callback function, which simply exits GTK.
544 Another course of events, is to use the window manager to kill the window.
545 This will cause the "delete_event" to be emitted. This will call our
546 "delete_event" handler. If we return TRUE here, the window will be left as
547 is and nothing will happen. Returning FALSE will cause GTK to emit the
548 "destroy" signal which of course, calls the "destroy" callback, exiting GTK.
550 Note that these signals are not the same as the Unix system
551 signals, and are not implemented using them, although the terminology is
554 <!-- ***************************************************************** -->
556 <!-- ***************************************************************** -->
558 <!-- ----------------------------------------------------------------- -->
561 There are a few things you probably noticed in the previous examples that
563 gint, gchar etc. that you see are typedefs to int and char respectively. This is done
564 to get around that nasty dependency on the size of simple data types when doing calculations.
565 A good example is "gint32" which will be
566 typedef'd to a 32 bit integer for any given platform, whether it be the 64 bit
567 alpha, or the 32 bit i386. The
568 typedefs are very straight forward and intuitive. They are all defined in
569 glib/glib.h (which gets included from gtk.h).
571 You'll also notice the ability to use GtkWidget when the function calls for a GtkObject.
572 GTK is an object oriented design, and a widget is an object.
574 <!-- ----------------------------------------------------------------- -->
575 <sect1>More on Signal Handlers
577 Lets take another look at the gtk_signal_connect declaration.
580 gint gtk_signal_connect (GtkObject *object, gchar *name,
581 GtkSignalFunc func, gpointer func_data);
584 Notice the gint return value ? This is a tag that identifies your callback
585 function. As said above, you may have as many callbacks per signal and per
586 object as you need, and each will be executed in turn, in the order they
589 This tag allows you to remove this callback from the list by using:
591 void gtk_signal_disconnect (GtkObject *object,
594 So, by passing in the widget you wish to remove the handler from, and the
595 tag or id returned by one of the signal_connect functions, you can
596 disconnect a signal handler.
598 Another function to remove all the signal handers from an object is:
601 gtk_signal_handlers_destroy (GtkObject *object);
604 This call is fairly self explanatory. It simply removes all the current
605 signal handlers from the object passed in as the first argument.
607 <!-- ----------------------------------------------------------------- -->
608 <sect1>An Upgraded Hello World
610 Let's take a look at a slightly improved hello world with better examples
611 of callbacks. This will also introduce us to our next topic, packing
619 /* Our new improved callback. The data passed to this function is printed
621 void callback (GtkWidget *widget, gpointer *data)
623 g_print ("Hello again - %s was pressed\n", (char *) data);
626 /* another callback */
627 void delete_event (GtkWidget *widget, gpointer *data)
632 int main (int argc, char *argv[])
634 /* GtkWidget is the storage type for widgets */
639 /* this is called in all GTK applications. arguments are parsed from
640 * the command line and are returned to the application. */
641 gtk_init (&argc, &argv);
643 /* create a new window */
644 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
646 /* this is a new call, this just sets the title of our
647 * new window to "Hello Buttons!" */
648 gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");
650 /* Here we just set a handler for delete_event that immediately
652 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
653 GTK_SIGNAL_FUNC (delete_event), NULL);
656 /* sets the border width of the window. */
657 gtk_container_border_width (GTK_CONTAINER (window), 10);
659 /* we create a box to pack widgets into. this is described in detail
660 * in the "packing" section below. The box is not really visible, it
661 * is just used as a tool to arrange widgets. */
662 box1 = gtk_hbox_new(FALSE, 0);
664 /* put the box into the main window. */
665 gtk_container_add (GTK_CONTAINER (window), box1);
667 /* creates a new button with the label "Button 1". */
668 button = gtk_button_new_with_label ("Button 1");
670 /* Now when the button is clicked, we call the "callback" function
671 * with a pointer to "button 1" as it's argument */
672 gtk_signal_connect (GTK_OBJECT (button), "clicked",
673 GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
675 /* instead of gtk_container_add, we pack this button into the invisible
676 * box, which has been packed into the window. */
677 gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
679 /* always remember this step, this tells GTK that our preparation for
680 * this button is complete, and it can be displayed now. */
681 gtk_widget_show(button);
683 /* do these same steps again to create a second button */
684 button = gtk_button_new_with_label ("Button 2");
686 /* call the same callback function with a different argument,
687 * passing a pointer to "button 2" instead. */
688 gtk_signal_connect (GTK_OBJECT (button), "clicked",
689 GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
691 gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
693 /* The order in which we show the buttons is not really important, but I
694 * recommend showing the window last, so it all pops up at once. */
695 gtk_widget_show(button);
697 gtk_widget_show(box1);
699 gtk_widget_show (window);
701 /* rest in gtk_main and wait for the fun to begin! */
708 Compile this program using the same linking arguments as our first example.
709 You'll notice this time there is no easy way to exit the program, you have
710 to use your window manager or command line to kill it. A good exercise
711 for the reader would be to insert a third "Quit" button that will exit the
712 program. You may also wish to play with the options to
713 gtk_box_pack_start() while reading the next section.
714 Try resizing the window, and observe the behavior.
716 Just as a side note, there is another useful define for gtk_window_new() -
717 GTK_WINDOW_DIALOG. This interacts with the window manager a little
718 differently and should be used for transient windows.
720 <!-- ***************************************************************** -->
721 <sect>Packing Widgets
722 <!-- ***************************************************************** -->
725 When creating an application, you'll want to put more than one button
726 inside a window. Our first hello world example only used one widget so we
727 could simply use a gtk_container_add call to "pack" the widget into the
728 window. But when you want to put more than one widget into a window, how
729 do you control where that widget is positioned ? This is where packing
732 <!-- ----------------------------------------------------------------- -->
733 <sect1>Theory of Packing Boxes
735 Most packing is done by creating boxes as in the example above. These are
736 invisible widget containers that we can pack our widgets into and come in
737 two forms, a horizontal box, and a vertical box. When packing widgets
738 into a horizontal box, the objects are inserted horizontally from left to
739 right or right to left depending on the call used. In a vertical box,
740 widgets are packed from top to bottom or vice versa. You may use any
741 combination of boxes inside or beside other boxes to create the desired
744 To create a new horizontal box, we use a call to gtk_hbox_new(), and for
745 vertical boxes, gtk_vbox_new(). The gtk_box_pack_start() and
746 gtk_box_pack_end() functions are used to place objects inside of these
747 containers. The gtk_box_pack_start() function will start at the top and
748 work its way down in a vbox, and pack left to right in an hbox.
749 gtk_box_pack_end() will do the opposite, packing from bottom to top in a
750 vbox, and right to left in an hbox. Using these functions allow us to
751 right justify or left justify our widgets and may be mixed in any way to
752 achieve the desired effect. We will use gtk_box_pack_start() in most of
753 our examples. An object may be another container or a widget. And in
754 fact, many widgets are actually containers themselves including the
755 button, but we usually only use a label inside a button.
757 By using these calls, GTK knows where you want to place your widgets so it
758 can do automatic resizing and other nifty things. there's also a number
759 of options as to how your widgets should be packed. As you can imagine,
760 this method gives us a quite a bit of flexibility when placing and
763 <!-- ----------------------------------------------------------------- -->
764 <sect1>Details of Boxes
766 Because of this flexibility, packing boxes in GTK can be confusing at
767 first. There are a lot of options, and it's not immediately obvious how
768 they all fit together. In the end however, there are basically five
769 different styles you can get.
774 <IMG SRC="gtk_tut_packbox1.gif" VSPACE="15" HSPACE="10" WIDTH="528" HEIGHT="235"
775 ALT="Box Packing Example Image">
779 Each line contains one horizontal box (hbox) with several buttons. The
780 call to gtk_box_pack is shorthand for the call to pack each of the buttons
781 into the hbox. Each of the buttons is packed into the hbox the same way
782 (i.e. same arguments to the gtk_box_pack_start () function).
784 This is the declaration of the gtk_box_pack_start function.
787 void gtk_box_pack_start (GtkBox *box,
794 The first argument is the box you are packing the object into, the second
795 is this object. The objects will all be buttons for now, so we'll be
796 packing buttons into boxes.
798 The expand argument to gtk_box_pack_start() or gtk_box_pack_end() controls
799 whether the widgets are laid out in the box to fill in all the extra space
800 in the box so the box is expanded to fill the area alloted to it (TRUE).
801 Or the box is shrunk to just fit the widgets (FALSE). Setting expand to
802 FALSE will allow you to do right and left
803 justifying of your widgets. Otherwise, they will all expand to fit in the
804 box, and the same effect could be achieved by using only one of
805 gtk_box_pack_start or pack_end functions.
807 The fill argument to the gtk_box_pack functions control whether the extra
808 space is allocated to the objects themselves (TRUE), or as extra padding
809 in the box around these objects (FALSE). It only has an effect if the
810 expand argument is also TRUE.
812 When creating a new box, the function looks like this:
815 GtkWidget * gtk_hbox_new (gint homogeneous,
819 The homogeneous argument to gtk_hbox_new (and the same for gtk_vbox_new)
820 controls whether each object in the box has the same size (i.e. the same
821 width in an hbox, or the same height in a vbox). If it is set, the expand
822 argument to the gtk_box_pack routines is always turned on.
824 What's the difference between spacing (set when the box is created) and
825 padding (set when elements are packed)? Spacing is added between objects,
826 and padding is added on either side of an object. The following figure
827 should make it clearer:
831 <IMG ALIGN="center" SRC="gtk_tut_packbox2.gif" WIDTH="509" HEIGHT="213"
832 VSPACE="15" HSPACE="10" ALT="Box Packing Example Image">
836 Here is the code used to create the above images. I've commented it fairly
837 heavily so hopefully you won't have any problems following it. Compile it yourself
840 <!-- ----------------------------------------------------------------- -->
841 <sect1>Packing Demonstration Program
849 delete_event (GtkWidget *widget, gpointer *data)
854 /* Make a new hbox filled with button-labels. Arguments for the
855 * variables we're interested are passed in to this function.
856 * We do not show the box, but do show everything inside. */
857 GtkWidget *make_box (gint homogeneous, gint spacing,
858 gint expand, gint fill, gint padding)
864 /* create a new hbox with the appropriate homogeneous and spacing
866 box = gtk_hbox_new (homogeneous, spacing);
868 /* create a series of buttons with the appropriate settings */
869 button = gtk_button_new_with_label ("gtk_box_pack");
870 gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
871 gtk_widget_show (button);
873 button = gtk_button_new_with_label ("(box,");
874 gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
875 gtk_widget_show (button);
877 button = gtk_button_new_with_label ("button,");
878 gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
879 gtk_widget_show (button);
881 /* create a button with the label depending on the value of
884 button = gtk_button_new_with_label ("TRUE,");
886 button = gtk_button_new_with_label ("FALSE,");
888 gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
889 gtk_widget_show (button);
891 /* This is the same as the button creation for "expand"
892 * above, but uses the shorthand form. */
893 button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
894 gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
895 gtk_widget_show (button);
897 sprintf (padstr, "%d);", padding);
899 button = gtk_button_new_with_label (padstr);
900 gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
901 gtk_widget_show (button);
907 main (int argc, char *argv[])
913 GtkWidget *separator;
918 /* Our init, don't forget this! :) */
919 gtk_init (&argc, &argv);
922 fprintf (stderr, "usage: packbox num, where num is 1, 2, or 3.\n");
923 /* this just does cleanup in GTK, and exits with an exit status of 1. */
927 which = atoi (argv[1]);
929 /* Create our window */
930 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
932 /* You should always remember to connect the destroy signal to the
933 * main window. This is very important for proper intuitive
935 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
936 GTK_SIGNAL_FUNC (delete_event), NULL);
937 gtk_container_border_width (GTK_CONTAINER (window), 10);
939 /* We create a vertical box (vbox) to pack the horizontal boxes into.
940 * This allows us to stack the horizontal boxes filled with buttons one
941 * on top of the other in this vbox. */
942 box1 = gtk_vbox_new (FALSE, 0);
944 /* which example to show. These correspond to the pictures above. */
947 /* create a new label. */
948 label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
950 /* Align the label to the left side. We'll discuss this function and
951 * others in the section on Widget Attributes. */
952 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
954 /* Pack the label into the vertical box (vbox box1). Remember that
955 * widgets added to a vbox will be packed one on top of the other in
957 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
960 gtk_widget_show (label);
962 /* call our make box function - homogeneous = FALSE, spacing = 0,
963 * expand = FALSE, fill = FALSE, padding = 0 */
964 box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
965 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
966 gtk_widget_show (box2);
968 /* call our make box function - homogeneous = FALSE, spacing = 0,
969 * expand = FALSE, fill = FALSE, padding = 0 */
970 box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
971 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
972 gtk_widget_show (box2);
974 /* Args are: homogeneous, spacing, expand, fill, padding */
975 box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
976 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
977 gtk_widget_show (box2);
979 /* creates a separator, we'll learn more about these later,
980 * but they are quite simple. */
981 separator = gtk_hseparator_new ();
983 /* pack the separator into the vbox. Remember each of these
984 * widgets are being packed into a vbox, so they'll be stacked
986 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
987 gtk_widget_show (separator);
989 /* create another new label, and show it. */
990 label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
991 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
992 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
993 gtk_widget_show (label);
995 /* Args are: homogeneous, spacing, expand, fill, padding */
996 box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
997 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
998 gtk_widget_show (box2);
1000 /* Args are: homogeneous, spacing, expand, fill, padding */
1001 box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
1002 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1003 gtk_widget_show (box2);
1005 /* another new separator. */
1006 separator = gtk_hseparator_new ();
1007 /* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
1008 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
1009 gtk_widget_show (separator);
1015 /* create a new label, remember box1 is a vbox as created
1016 * near the beginning of main() */
1017 label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
1018 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
1019 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
1020 gtk_widget_show (label);
1022 /* Args are: homogeneous, spacing, expand, fill, padding */
1023 box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
1024 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1025 gtk_widget_show (box2);
1027 /* Args are: homogeneous, spacing, expand, fill, padding */
1028 box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
1029 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1030 gtk_widget_show (box2);
1032 separator = gtk_hseparator_new ();
1033 /* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
1034 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
1035 gtk_widget_show (separator);
1037 label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
1038 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
1039 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
1040 gtk_widget_show (label);
1042 /* Args are: homogeneous, spacing, expand, fill, padding */
1043 box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
1044 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1045 gtk_widget_show (box2);
1047 /* Args are: homogeneous, spacing, expand, fill, padding */
1048 box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
1049 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1050 gtk_widget_show (box2);
1052 separator = gtk_hseparator_new ();
1053 /* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
1054 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
1055 gtk_widget_show (separator);
1060 /* This demonstrates the ability to use gtk_box_pack_end() to
1061 * right justify widgets. First, we create a new box as before. */
1062 box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
1063 /* create the label that will be put at the end. */
1064 label = gtk_label_new ("end");
1065 /* pack it using gtk_box_pack_end(), so it is put on the right side
1066 * of the hbox created in the make_box() call. */
1067 gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
1068 /* show the label. */
1069 gtk_widget_show (label);
1071 /* pack box2 into box1 (the vbox remember ? :) */
1072 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1073 gtk_widget_show (box2);
1075 /* a separator for the bottom. */
1076 separator = gtk_hseparator_new ();
1077 /* this explicitly sets the separator to 400 pixels wide by 5 pixels
1078 * high. This is so the hbox we created will also be 400 pixels wide,
1079 * and the "end" label will be separated from the other labels in the
1080 * hbox. Otherwise, all the widgets in the hbox would be packed as
1081 * close together as possible. */
1082 gtk_widget_set_usize (separator, 400, 5);
1083 /* pack the separator into the vbox (box1) created near the start
1085 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
1086 gtk_widget_show (separator);
1089 /* Create another new hbox.. remember we can use as many as we need! */
1090 quitbox = gtk_hbox_new (FALSE, 0);
1092 /* Our quit button. */
1093 button = gtk_button_new_with_label ("Quit");
1095 /* setup the signal to destroy the window. Remember that this will send
1096 * the "destroy" signal to the window which will be caught by our signal
1097 * handler as defined above. */
1098 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1099 GTK_SIGNAL_FUNC (gtk_main_quit),
1100 GTK_OBJECT (window));
1101 /* pack the button into the quitbox.
1102 * The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
1103 gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
1104 /* pack the quitbox into the vbox (box1) */
1105 gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
1107 /* pack the vbox (box1) which now contains all our widgets, into the
1109 gtk_container_add (GTK_CONTAINER (window), box1);
1111 /* and show everything left */
1112 gtk_widget_show (button);
1113 gtk_widget_show (quitbox);
1115 gtk_widget_show (box1);
1116 /* Showing the window last so everything pops up at once. */
1117 gtk_widget_show (window);
1119 /* And of course, our main function. */
1122 /* control returns here when gtk_main_quit() is called, but not when
1123 * gtk_exit is used. */
1129 <!-- ----------------------------------------------------------------- -->
1130 <sect1>Packing Using Tables
1132 Let's take a look at another way of packing - Tables. These can be
1133 extremely useful in certain situations.
1135 Using tables, we create a grid that we can place widgets in. The widgets
1136 may take up as many spaces as we specify.
1138 The first thing to look at of course, is the gtk_table_new function:
1141 GtkWidget* gtk_table_new (gint rows,
1146 The first argument is the number of rows to make in the table, while the
1147 second, obviously, the number of columns.
1149 The homogeneous argument has to do with how the table's boxes are sized. If homogeneous
1150 is TRUE, the table boxes are resized to the size of the largest widget in the table.
1151 If homogeneous is FALSE, the size of a table boxes is dictated by the tallest widget
1152 in its same row, and the widest widget in its column.
1154 The rows and columnts are laid out starting with 0 to n, where n was the
1155 number specified in the call to gtk_table_new. So, if you specify rows = 2 and
1156 columns = 2, the layout would look something like this:
1160 0+----------+----------+
1162 1+----------+----------+
1164 2+----------+----------+
1167 Note that the coordinate system starts in the upper left hand corner. To place a
1168 widget into a box, use the following function:
1171 void gtk_table_attach (GtkTable *table,
1183 Where the first argument ("table") is the table you've created and the second
1184 ("child") the widget you wish to place in the table.
1186 The left and right attach
1187 arguments specify where to place the widget, and how many boxes to use. If you want
1188 a button in the lower right table entry
1189 of our 2x2 table, and want it to fill that entry ONLY. left_attach would be = 1,
1190 right_attach = 2, top_attach = 1, bottom_attach = 2.
1192 Now, if you wanted a widget to take up the whole
1193 top row of our 2x2 table, you'd use left_attach = 0, right_attach =2, top_attach = 0,
1196 The xoptions and yoptions are used to specify packing options and may be OR'ed
1197 together to allow multiple options.
1201 <item>GTK_FILL - If the table box is larger than the widget, and GTK_FILL is
1202 specified, the widget will expand to use all the room available.
1204 <item>GTK_SHRINK - If the table widget was allocated less space then was
1205 requested (usually by the user resizing the window), then the widgets would
1206 normally just be pushed off the bottom of
1207 the window and disappear. If GTK_SHRINK is specified, the widgets will
1208 shrink with the table.
1210 <item>GTK_EXPAND - This will cause the table to expand to use up any remaining
1211 space in the window.
1214 Padding is just like in boxes, creating a clear area around the widget
1215 specified in pixels.
1217 gtk_table_attach() has a LOT of options. So, there's a shortcut:
1220 void gtk_table_attach_defaults (GtkTable *table,
1225 gint bottom_attach);
1228 The X and Y options default to GTK_FILL | GTK_EXPAND, and X and Y padding
1229 are set to 0. The rest of the arguments are identical to the previous
1232 We also have gtk_table_set_row_spacing() and gtk_table_set_col_spacing().
1233 This places spacing between the rows at the specified row or column.
1236 void gtk_table_set_row_spacing (GtkTable *table,
1242 void gtk_table_set_col_spacing (GtkTable *table,
1247 Note that for columns, the space goes to the right of the column, and for
1248 rows, the space goes below the row.
1250 You can also set a consistent spacing of all rows and/or columns with:
1253 void gtk_table_set_row_spacings (GtkTable *table,
1259 void gtk_table_set_col_spacings (GtkTable *table,
1263 Note that with these calls, the last row and last column do not get any
1266 <!-- ----------------------------------------------------------------- -->
1267 <sect1>Table Packing Example
1269 Here we make a window with three buttons in a 2x2 table.
1270 The first two buttons will be placed in the upper row.
1271 A third, quit button, is placed in the lower row, spanning both columns.
1272 Which means it should look something like this:
1276 <IMG SRC="gtk_tut_table.gif" VSPACE="15" HSPACE="10"
1277 ALT="Table Packing Example Image" WIDTH="180" HEIGHT="120">
1281 Here's the source code:
1285 #include <gtk/gtk.h>
1288 * the data passed to this function is printed to stdout */
1289 void callback (GtkWidget *widget, gpointer *data)
1291 g_print ("Hello again - %s was pressed\n", (char *) data);
1294 /* this callback quits the program */
1295 void delete_event (GtkWidget *widget, gpointer *data)
1300 int main (int argc, char *argv[])
1306 gtk_init (&argc, &argv);
1308 /* create a new window */
1309 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1311 /* set the window title */
1312 gtk_window_set_title (GTK_WINDOW (window), "Table");
1314 /* set a handler for delete_event that immediately
1316 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1317 GTK_SIGNAL_FUNC (delete_event), NULL);
1319 /* sets the border width of the window. */
1320 gtk_container_border_width (GTK_CONTAINER (window), 20);
1322 /* create a 2x2 table */
1323 table = gtk_table_new (2, 2, TRUE);
1325 /* put the table in the main window */
1326 gtk_container_add (GTK_CONTAINER (window), table);
1328 /* create first button */
1329 button = gtk_button_new_with_label ("button 1");
1331 /* when the button is clicked, we call the "callback" function
1332 * with a pointer to "button 1" as it's argument */
1333 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1334 GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
1337 /* insert button 1 into the upper left quadrant of the table */
1338 gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);
1340 gtk_widget_show (button);
1342 /* create second button */
1344 button = gtk_button_new_with_label ("button 2");
1346 /* when the button is clicked, we call the "callback" function
1347 * with a pointer to "button 2" as it's argument */
1348 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1349 GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
1350 /* insert button 2 into the upper right quadrant of the table */
1351 gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);
1353 gtk_widget_show (button);
1355 /* create "Quit" button */
1356 button = gtk_button_new_with_label ("Quit");
1358 /* when the button is clicked, we call the "delete_event" function
1359 * and the program exits */
1360 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1361 GTK_SIGNAL_FUNC (delete_event), NULL);
1363 /* insert the quit button into the both
1364 * lower quadrants of the table */
1365 gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);
1367 gtk_widget_show (button);
1369 gtk_widget_show (table);
1370 gtk_widget_show (window);
1377 <!-- ***************************************************************** -->
1378 <sect>Widget Overview
1379 <!-- ***************************************************************** -->
1382 The general steps to creating a widget in GTK are:
1384 <item> gtk_*_new - one of various functions to create a new widget. These
1385 are all detailed in this section.
1387 <item> Connect all signals we wish to use to the appropriate handlers.
1389 <item> Set the attributes of the widget.
1391 <item> Pack the widget into a container using the appropriate call such as
1392 gtk_container_add() or gtk_box_pack_start().
1394 <item> gtk_widget_show() the widget.
1397 gtk_widget_show() lets GTK know that we are done setting the attributes
1398 of the widget, and it is ready to be displayed. You may also use
1399 gtk_widget_hide to make it disappear again. The order in which you
1400 show the widgets is not important, but I suggest showing the window
1401 last so the whole window pops up at once rather than seeing the individual
1402 widgets come up on the screen as they're formed. The children of a widget
1403 (a window is a widget too)
1404 will not be displayed until the window itself is shown using the
1405 gtk_widget_show() function.
1407 <!-- ----------------------------------------------------------------- -->
1410 You'll notice as you go on, that GTK uses a type casting system. This is
1411 always done using macros that both test the ability to cast the given item,
1412 and perform the cast. Some common ones you will see are:
1415 <item> GTK_WIDGET(widget)
1416 <item> GTK_OBJECT(object)
1417 <item> GTK_SIGNAL_FUNC(function)
1418 <item> GTK_CONTAINER(container)
1419 <item> GTK_WINDOW(window)
1423 These are all used to cast arguments in functions. You'll see them in the
1424 examples, and can usually tell when to use them simply by looking at the
1425 function's declaration.
1427 As you can see below in the class hierarchy, all GtkWidgets are derived from
1428 the GtkObject base class. This means you can use an widget in any place the
1429 function asks for an object - simply use the GTK_OBJECT() macro.
1434 gtk_signal_connect(GTK_OBJECT(button), "clicked",
1435 GTK_SIGNAL_FUNC(callback_function), callback_data);
1438 This casts the button into an object, and provides a cast for the function
1439 pointer to the callback.
1441 Many widgets are also containers. If you look in the class hierarchy below,
1442 you'll notice that many widgets drive from the GtkContainer class. Any one
1443 of those widgets may use with the GTK_CONTAINER macro to
1444 pass them to functions that ask for containers.
1446 Unfortunately, these macros are not extensively covered in the tutorial, but I
1447 recomend taking a look through the GTK header files. It can be very
1448 educational. In fact, it's not difficult to learn how a widget works just
1449 by looking at the function declarations.
1451 <!-- ----------------------------------------------------------------- -->
1452 <sect1>Widget Hierarchy
1454 For your reference, here is the class hierarchy tree used to implement widgets.
1467 | | | `GtkAspectFrame
1472 | | | | `GtkCheckMenuItem
1473 | | | | `GtkRadioMenuItem
1477 | | +GtkColorSelectionDialog
1479 | | | `GtkInputDialog
1480 | | `GtkFileSelection
1483 | | | +GtkHButtonBox
1484 | | | `GtkVButtonBox
1489 | | +GtkColorSelection
1493 | | `GtkToggleButton
1506 | +GtkScrolledWindow
1539 <!-- ----------------------------------------------------------------- -->
1540 <sect1>Widgets Without Windows
1542 The following widgets do not have an associated window. If you want to
1543 capture events, you'll have to use the GtkEventBox. See the section on
1544 <ref id="sec_The_EventBox_Widget" name="The EventBox Widget">
1566 We'll further our exploration of GTK by examining each widget in turn,
1567 creating a few simple functions to display them. Another good source is
1568 the testgtk.c program that comes with GTK. It can be found in
1571 <!-- ***************************************************************** -->
1572 <sect>The Button Widget
1573 <!-- ***************************************************************** -->
1575 <!-- ----------------------------------------------------------------- -->
1576 <sect1>Normal Buttons
1578 We've almost seen all there is to see of the button widget. It's pretty
1579 simple. There is however two ways to create a button. You can use the
1580 gtk_button_new_with_label() to create a button with a label, or use
1581 gtk_button_new() to create a blank button. It's then up to you to pack a
1582 label or pixmap into this new button. To do this, create a new box, and
1583 then pack your objects into this box using the usual gtk_box_pack_start,
1584 and then use gtk_container_add to pack the box into the button.
1586 Here's an example of using gtk_button_new to create a button with a
1587 picture and a label in it. I've broken the code to create a box up from
1588 the rest so you can use it in your programs.
1593 #include <gtk/gtk.h>
1595 /* create a new hbox with an image and a label packed into it
1596 * and return the box.. */
1598 GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, gchar *label_text)
1602 GtkWidget *pixmapwid;
1607 /* create box for xpm and label */
1608 box1 = gtk_hbox_new (FALSE, 0);
1609 gtk_container_border_width (GTK_CONTAINER (box1), 2);
1611 /* get style of button.. I assume it's to get the background color.
1612 * if someone knows the real reason, please enlighten me. */
1613 style = gtk_widget_get_style(parent);
1615 /* now on to the xpm stuff.. load xpm */
1616 pixmap = gdk_pixmap_create_from_xpm (parent->window, &mask,
1617 &style->bg[GTK_STATE_NORMAL],
1619 pixmapwid = gtk_pixmap_new (pixmap, mask);
1621 /* create label for button */
1622 label = gtk_label_new (label_text);
1624 /* pack the pixmap and label into the box */
1625 gtk_box_pack_start (GTK_BOX (box1),
1626 pixmapwid, FALSE, FALSE, 3);
1628 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 3);
1630 gtk_widget_show(pixmapwid);
1631 gtk_widget_show(label);
1636 /* our usual callback function */
1637 void callback (GtkWidget *widget, gpointer *data)
1639 g_print ("Hello again - %s was pressed\n", (char *) data);
1643 int main (int argc, char *argv[])
1645 /* GtkWidget is the storage type for widgets */
1650 gtk_init (&argc, &argv);
1652 /* create a new window */
1653 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1655 gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!");
1657 /* It's a good idea to do this for all windows. */
1658 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1659 GTK_SIGNAL_FUNC (gtk_exit), NULL);
1661 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1662 GTK_SIGNAL_FUNC (gtk_exit), NULL);
1665 /* sets the border width of the window. */
1666 gtk_container_border_width (GTK_CONTAINER (window), 10);
1667 gtk_widget_realize(window);
1669 /* create a new button */
1670 button = gtk_button_new ();
1672 /* You should be getting used to seeing most of these functions by now */
1673 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1674 GTK_SIGNAL_FUNC (callback), (gpointer) "cool button");
1676 /* this calls our box creating function */
1677 box1 = xpm_label_box(window, "info.xpm", "cool button");
1679 /* pack and show all our widgets */
1680 gtk_widget_show(box1);
1682 gtk_container_add (GTK_CONTAINER (button), box1);
1684 gtk_widget_show(button);
1686 gtk_container_add (GTK_CONTAINER (window), button);
1688 gtk_widget_show (window);
1690 /* rest in gtk_main and wait for the fun to begin! */
1697 The xpm_label_box function could be used to pack xpm's and labels into any
1698 widget that can be a container.
1700 <!-- ----------------------------------------------------------------- -->
1701 <sect1> Toggle Buttons
1703 Toggle buttons are very similar to normal buttons, except they will always
1704 be in one of two states, alternated by a click. They may be depressed, and
1705 when you click again, they will pop back up. Click again, and they will pop
1708 Toggle buttons are the basis for check buttons and radio buttons, as such,
1709 many of the calls used for toggle buttons are inherited by radio and check
1710 buttons. I will point these out when we come to them.
1712 Creating a new toggle button:
1715 GtkWidget* gtk_toggle_button_new (void);
1717 GtkWidget* gtk_toggle_button_new_with_label (gchar *label);
1720 As you can imagine, these work identically to the normal button widget
1721 calls. The first creates a blank toggle button, and the second, a button
1722 with a label widget already packed into it.
1724 To retrieve the state of the toggle widget, including radio and check
1725 buttons, we use a macro as shown in our example below. This tests the state
1726 of the toggle in a callback. The signal of interest emitted to us by toggle
1727 buttons (the toggle button, check button, and radio button widgets), is the
1728 "toggled" signal. To check the state of these buttons, set up a signal
1729 handler to catch the toggled signal, and use the macro to determine it's
1730 state. The callback will look something like:
1733 void toggle_button_callback (GtkWidget *widget, gpointer data)
1735 if (GTK_TOGGLE_BUTTON (widget)->active)
1737 /* If control reaches here, the toggle button is down */
1741 /* If control reaches here, the toggle button is up */
1751 guint gtk_toggle_button_get_type (void);
1754 No idea... they all have this, but I dunno what it is :)
1758 void gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
1759 gint draw_indicator);
1766 void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
1770 The above call can be used to set the state of the toggle button, and it's
1771 children the radio and check buttons. Passing
1772 in your created button as the first argument, and a TRUE or FALSE
1773 for the second state argument to specify whether it should be up (released) or
1774 down (depressed). Default is up, or FALSE.
1776 Note that when you use the gtk_toggle_button_set_state() function, and the
1777 state is actually changed, it causes
1778 the "clicked" signal to be emitted from the button.
1781 void gtk_toggle_button_toggled (GtkToggleButton *toggle_button);
1784 This simply toggles the button, and emits the "toggled" signal.
1786 <!-- ----------------------------------------------------------------- -->
1787 <sect1> Check Buttons
1789 Check buttons inherent many properties and functions from the the toggle buttons above,
1791 different. Rather than being buttons with text inside them, they are small
1792 squares with the text to the right of them. These are often seen for
1793 toggling options on and off in applications.
1795 The two creation functions are the same as for the normal button.
1798 GtkWidget* gtk_check_button_new (void);
1800 GtkWidget* gtk_check_button_new_with_label (gchar *label);
1803 The new_with_label function creates a check button with a label beside it.
1805 Checking the state of the check button is identical to that of the toggle
1808 <!-- ----------------------------------------------------------------- -->
1809 <sect1> Radio Buttons
1811 Radio buttons are similar to check buttons except they are grouped so that
1812 only one may be selected/depressed at a time. This is good for places in
1813 your application where you need to select from a short list of options.
1815 Creating a new radio button is done with one of these calls:
1818 GtkWidget* gtk_radio_button_new (GSList *group);
1820 GtkWidget* gtk_radio_button_new_with_label (GSList *group,
1824 You'll notice the extra argument to these calls. They require a group to
1825 perform they're duty properly. The first call should pass NULL as the first
1826 argument. Then create a group using:
1829 GSList* gtk_radio_button_group (GtkRadioButton *radio_button);
1833 The important thing to remember is that gtk_radio_button_group must be
1834 called for each new button added to the group, with the previous button
1835 passed in as an argument. The result is then passed into the call to
1836 gtk_radio_button_new or gtk_radio_button_new_with_label. This allows a
1837 chain of buttons to be established. The example below should make this
1840 It is also a good idea to explicitly set which button should be the
1841 default depressed button with:
1844 void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
1848 This is described in the section on toggle buttons, and works in exactly the
1851 The following example creates a radio button group with three buttons.
1854 /* radiobuttons.c */
1856 #include <gtk/gtk.h>
1859 void close_application( GtkWidget *widget, gpointer *data ) {
1863 main(int argc,char *argv[])
1865 static GtkWidget *window = NULL;
1869 GtkWidget *separator;
1872 gtk_init(&argc,&argv);
1873 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1875 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1876 GTK_SIGNAL_FUNC(close_application),
1879 gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
1880 gtk_container_border_width (GTK_CONTAINER (window), 0);
1882 box1 = gtk_vbox_new (FALSE, 0);
1883 gtk_container_add (GTK_CONTAINER (window), box1);
1884 gtk_widget_show (box1);
1886 box2 = gtk_vbox_new (FALSE, 10);
1887 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1888 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1889 gtk_widget_show (box2);
1891 button = gtk_radio_button_new_with_label (NULL, "button1");
1892 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1893 gtk_widget_show (button);
1895 group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1896 button = gtk_radio_button_new_with_label(group, "button2");
1897 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
1898 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1899 gtk_widget_show (button);
1901 group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1902 button = gtk_radio_button_new_with_label(group, "button3");
1903 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1904 gtk_widget_show (button);
1906 separator = gtk_hseparator_new ();
1907 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1908 gtk_widget_show (separator);
1910 box2 = gtk_vbox_new (FALSE, 10);
1911 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1912 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1913 gtk_widget_show (box2);
1915 button = gtk_button_new_with_label ("close");
1916 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1917 GTK_SIGNAL_FUNC(close_application),
1918 GTK_OBJECT (window));
1919 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1920 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1921 gtk_widget_grab_default (button);
1922 gtk_widget_show (button);
1923 gtk_widget_show (window);
1930 You can shorten this slightly by using the following syntax, which
1931 removes the need for a variable to hold the list of buttons:
1934 button2 = gtk_radio_button_new_with_label(
1935 gtk_radio_button_group (GTK_RADIO_BUTTON (button1)),
1939 <!-- ***************************************************************** -->
1940 <sect> Miscallaneous Widgets
1941 <!-- ***************************************************************** -->
1943 <!-- ----------------------------------------------------------------- -->
1946 Labels are used a lot in GTK, and are relatively simple. Labels emit no
1947 signals as they do not have an associated X window. If you need to catch
1948 signals, or do clipping, use the EventBox widget.
1950 To create a new label, use:
1953 GtkWidget* gtk_label_new (char *str);
1956 Where the sole argument is the string you wish the label to display.
1958 To change the label's text after creation, use the function:
1961 void gtk_label_set (GtkLabel *label,
1965 Where the first argument is the label you created previously (casted using
1966 the GTK_LABEL() macro), and the second is the new string.
1968 The space needed for the new string will be automatically adjusted if needed.
1970 To retrieve the current string, use:
1973 void gtk_label_get (GtkLabel *label,
1977 Where the first arguement is the label you've created, and the second, the
1978 return for the string.
1980 <!-- ----------------------------------------------------------------- -->
1981 <sect1>The Tooltips Widget
1983 These are the little text strings that pop up when you leave your pointer
1984 over a button or other widget for a few seconds. They are easy to use, so I
1985 will just explain them without giving an example. If you want to see some
1986 code, take a look at the testgtk.c program distributed with GDK.
1988 Some widgets (such as the label) will not work with tooltips.
1990 The first call you will use to create a new tooltip. You only need to do
1991 this once in a given function. The GtkTooltip this function returns can be
1992 used to create multiple tooltips.
1995 GtkTooltips *gtk_tooltips_new (void);
1998 Once you have created a new tooltip, and the widget you wish to use it on,
1999 simply use this call to set it.
2002 void gtk_tooltips_set_tips (GtkTooltips *tooltips,
2007 The first argument is the tooltip you've already created, followed by the
2008 widget you wish to have this tooltip pop up for, and the text you wish it to
2011 Here's a short example:
2014 GtkTooltips *tooltips;
2017 tooltips = gtk_tooltips_new ();
2018 button = gtk_button_new_with_label ("button 1");
2020 gtk_tooltips_set_tips (tooltips, button, "This is button 1");
2024 There are other calls used with tooltips. I will just list them with a
2025 brief description of what they do.
2028 void gtk_tooltips_destroy (GtkTooltips *tooltips);
2031 Destroy the created tooltips.
2034 void gtk_tooltips_enable (GtkTooltips *tooltips);
2037 Enable a disabled set of tooltips.
2040 void gtk_tooltips_disable (GtkTooltips *tooltips);
2043 Disable an enabled set of tooltips.
2046 void gtk_tooltips_set_delay (GtkTooltips *tooltips,
2050 Sets how many milliseconds you have to hold you pointer over the widget before the
2051 tooltip will pop up. The default is 1000 milliseconds or 1 second.
2054 void gtk_tooltips_set_tips (GtkTooltips *tooltips,
2059 Change the tooltip text of an already created tooltip.
2062 void gtk_tooltips_set_colors (GtkTooltips *tooltips,
2063 GdkColor *background,
2064 GdkColor *foreground);
2067 Set the foreground and background color of the tooltips. Again, I have no
2068 idea how to specify the colors.
2070 And that's all the functions associated with tooltips. More than you'll
2071 ever want to know :)
2073 <!-- ----------------------------------------------------------------- -->
2074 <sect1> Progress Bars
2076 Progress bars are used to show the status of an operation. They are pretty
2077 easy to use, as you will see with the code below. But first lets start out
2078 with the call to create a new progress bar.
2081 GtkWidget *gtk_progress_bar_new (void);
2084 Now that the progress bar has been created we can use it.
2087 void gtk_progress_bar_update (GtkProgressBar *pbar, gfloat percentage);
2090 The first argument is the progress bar you wish to operate on, and the second
2091 argument is the amount 'completed', meaning the amount the progress bar has
2092 been filled from 0-100% (a real number between 0 and 1).
2094 Progress Bars are usually used with timeouts or other such functions (see
2095 section on <ref id="sec_timeouts" name="Timeouts, I/O and Idle Functions">)
2096 to give the illusion of multitasking. All will employ
2097 the gtk_progress_bar_update function in the same manner.
2099 Here is an example of the progress bar, updated using timeouts. This
2100 code also shows you how to reset the Progress Bar.
2105 #include <gtk/gtk.h>
2107 static int ptimer = 0;
2110 /* This function increments and updates the progress bar, it also resets
2111 the progress bar if pstat is FALSE */
2112 gint progress (gpointer data)
2116 /* get the current value of the progress bar */
2117 pvalue = GTK_PROGRESS_BAR (data)->percentage;
2119 if ((pvalue >= 1.0) || (pstat == FALSE)) {
2125 gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
2130 /* This function signals a reset of the progress bar */
2131 void progress_r (void)
2136 void destroy (GtkWidget *widget, gpointer *data)
2141 int main (int argc, char *argv[])
2149 gtk_init (&argc, &argv);
2151 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2153 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2154 GTK_SIGNAL_FUNC (destroy), NULL);
2156 gtk_container_border_width (GTK_CONTAINER (window), 10);
2158 table = gtk_table_new(3,2,TRUE);
2159 gtk_container_add (GTK_CONTAINER (window), table);
2161 label = gtk_label_new ("Progress Bar Example");
2162 gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
2163 gtk_widget_show(label);
2165 /* Create a new progress bar, pack it into the table, and show it */
2166 pbar = gtk_progress_bar_new ();
2167 gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
2168 gtk_widget_show (pbar);
2170 /* Set the timeout to handle automatic updating of the progress bar */
2171 ptimer = gtk_timeout_add (100, progress, pbar);
2173 /* This button signals the progress bar to be reset */
2174 button = gtk_button_new_with_label ("Reset");
2175 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2176 GTK_SIGNAL_FUNC (progress_r), NULL);
2177 gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
2178 gtk_widget_show(button);
2180 button = gtk_button_new_with_label ("Cancel");
2181 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2182 GTK_SIGNAL_FUNC (destroy), NULL);
2184 gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
2185 gtk_widget_show (button);
2187 gtk_widget_show(table);
2188 gtk_widget_show(window);
2196 In this small program there are four areas that concern the general operation
2197 of Progress Bars, we will look at them in the order they are called.
2200 pbar = gtk_progress_bar_new ();
2203 This code creates a new progress bar, called pbar.
2206 ptimer = gtk_timeout_add (100, progress, pbar);
2209 This code, uses timeouts to enable a constant time interval, timeouts are
2210 not necessary in the use of Progress Bars.
2213 pvalue = GTK_PROGRESS_BAR (data)->percentage;
2216 This code assigns the current value of the percentage bar to pvalue.
2219 gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
2222 Finally, this code updates the progress bar with the value of pvalue
2224 And that is all there is to know about Progress Bars, enjoy.
2226 <!-- ----------------------------------------------------------------- -->
2230 The Dialog widget is very simple, and is actually just a window with a few
2231 things pre-packed into it for you. The structure for a Dialog is:
2239 GtkWidget *action_area;
2243 So you see, it simple creates a window, and then packs a vbox into the top,
2244 then a seperator, and then an hbox for the "action_area".
2246 The Dialog widget can be used for pop-up messages to the user, and
2247 other similar tasks. It is really basic, and there is only one
2248 function for the dialog box, which is:
2251 GtkWidget* gtk_dialog_new (void);
2254 So to create a new dialog box, use,
2258 window = gtk_dialog_new ();
2261 This will create the dialog box, and it is now up to you to use it.
2262 you could pack a button in the action_area by doing something like so:
2266 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
2268 gtk_widget_show (button);
2271 And you could add to the vbox area by packing, for instance, a label
2272 in it, try something like this:
2275 label = gtk_label_new ("Dialogs are groovy");
2276 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE,
2278 gtk_widget_show (label);
2281 As an example in using the dialog box, you could put two buttons in
2282 the action_area, a Cancel button and an Ok button, and a label in the vbox
2283 area, asking the user a question or giving an error etc. Then you could
2284 attach a different signal to each of the buttons and perform the
2285 operation the user selects.
2287 <!-- ----------------------------------------------------------------- -->
2290 Pixmaps are data structures that contain pictures. These pictures can be
2291 used in various places, but most visibly as icons on the X-Windows desktop,
2292 or as cursors. A bitmap is a 2-color pixmap.
2294 To use pixmaps in GTK, we must first build a GdkPixmap structure using
2295 routines from the GDK layer. Pixmaps can either be created from in-memory
2296 data, or from data read from a file. We'll go through each of the calls
2300 GdkPixmap *gdk_bitmap_create_from_data( GdkWindow *window,
2306 This routine is used to create a single-plane pixmap (2 colors) from data in
2307 memory. Each bit of the data represents whether that pixel is off or on.
2308 Width and height are in pixels. The GdkWindow pointer is to the current
2309 window, since a pixmap resources are meaningful only in the context of the
2310 screen where it is to be displayed.
2313 GdkPixmap* gdk_pixmap_create_from_data( GdkWindow *window,
2322 This is used to create a pixmap of the given depth (number of colors) from
2323 the bitmap data specified. fg and bg are the foreground and background
2327 GdkPixmap* gdk_pixmap_create_from_xpm( GdkWindow *window,
2329 GdkColor *transparent_color,
2330 const gchar *filename );
2333 XPM format is a readable pixmap representation for the X Window System. It
2334 is widely used and many different utilities are available for creating image
2335 files in this format. The file specified by filename must contain an image
2336 in that format and it is loaded into the pixmap structure. The mask specifies
2337 what bits of the pixmap are opaque. All other bits are colored using the
2338 color specified by transparent_color. An example using this follows below.
2341 GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow *window,
2343 GdkColor *transparent_color,
2347 Small images can be incorporated into a program as data in the XPM format.
2348 A pixmap is created using this data, instead of reading it from a file.
2349 An example of such data is
2353 static const char * xpm_data[] = {
2356 ". c #000000000000",
2357 "X c #FFFFFFFFFFFF",
2377 void gdk_pixmap_destroy( GdkPixmap *pixmap );
2380 When we're done using a pixmap and not likely to reuse it again soon,
2381 it is a good idea to release the resource using gdk_pixmap_destroy. Pixmaps
2382 should be considered a precious resource.
2385 Once we've created a pixmap, we can display it as a GTK widget. We must
2386 create a pixmap widget to contain the GDK pixmap. This is done using
2389 GtkWidget* gtk_pixmap_new( GdkPixmap *pixmap,
2393 The other pixmap widget calls are
2396 guint gtk_pixmap_get_type( void );
2397 void gtk_pixmap_set( GtkPixmap *pixmap,
2400 void gtk_pixmap_get( GtkPixmap *pixmap,
2405 gtk_pixmap_set is used to change the pixmap that the widget is currently
2406 managing. Val is the pixmap created using GDK.
2408 The following is an example of using a pixmap in a button.
2413 #include <gtk/gtk.h>
2416 /* XPM data of Open-File icon */
2417 static const char * xpm_data[] = {
2420 ". c #000000000000",
2421 "X c #FFFFFFFFFFFF",
2440 /* when invoked (via signal delete_event), terminates the application.
2442 void close_application( GtkWidget *widget, gpointer *data ) {
2447 /* is invoked when the button is clicked. It just prints a message.
2449 void button_clicked( GtkWidget *widget, gpointer *data ) {
2450 printf( "button clicked\n" );
2453 int main( int argc, char *argv[] )
2455 /* GtkWidget is the storage type for widgets */
2456 GtkWidget *window, *pixmapwid, *button;
2461 /* create the main window, and attach delete_event signal to terminating
2463 gtk_init( &argc, &argv );
2464 window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
2465 gtk_signal_connect( GTK_OBJECT (window), "delete_event",
2466 GTK_SIGNAL_FUNC (close_application), NULL );
2467 gtk_container_border_width( GTK_CONTAINER (window), 10 );
2468 gtk_widget_show( window );
2470 /* now for the pixmap from gdk */
2471 style = gtk_widget_get_style( window );
2472 pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
2473 &style->bg[GTK_STATE_NORMAL],
2474 (gchar **)xpm_data );
2476 /* a pixmap widget to contain the pixmap */
2477 pixmapwid = gtk_pixmap_new( pixmap, mask );
2478 gtk_widget_show( pixmapwid );
2480 /* a button to contain the pixmap widget */
2481 button = gtk_button_new();
2482 gtk_container_add( GTK_CONTAINER(button), pixmapwid );
2483 gtk_container_add( GTK_CONTAINER(window), button );
2484 gtk_widget_show( button );
2486 gtk_signal_connect( GTK_OBJECT(button), "clicked",
2487 GTK_SIGNAL_FUNC(button_clicked), NULL );
2489 /* show the window */
2497 To load a file from an XPM data file called icon0.xpm in the current
2498 directory, we would have created the pixmap thus
2501 /* load a pixmap from a file */
2502 pixmap = gdk_pixmap_create_from_xpm( window->window, &mask,
2503 &style->bg[GTK_STATE_NORMAL],
2505 pixmapwid = gtk_pixmap_new( pixmap, mask );
2506 gtk_widget_show( pixmapwid );
2507 gtk_container_add( GTK_CONTAINER(window), pixmapwid );
2514 A disadvantage of using pixmaps is that the displayed object is always
2515 rectangular, regardless of the image. We would like to create desktops
2516 and applications with icons that have more natural shapes. For example,
2517 for a game interface, we would like to have round buttons to push. The
2518 way to do this is using shaped windows.
2520 A shaped window is simply a pixmap where the background pixels are
2521 transparent. This way, when the background image is multi-colored, we
2522 don't overwrite it with a rectangular, non-matching border around our
2523 icon. The following example displays a full wheelbarrow image on the
2529 #include <gtk/gtk.h>
2532 static char * WheelbarrowFull_xpm[] = {
2535 ". c #DF7DCF3CC71B",
2536 "X c #965875D669A6",
2537 "o c #71C671C671C6",
2538 "O c #A699A289A699",
2539 "+ c #965892489658",
2540 "@ c #8E38410330C2",
2541 "# c #D75C7DF769A6",
2542 "$ c #F7DECF3CC71B",
2543 "% c #96588A288E38",
2544 "& c #A69992489E79",
2545 "* c #8E3886178E38",
2546 "= c #104008200820",
2547 "- c #596510401040",
2548 "; c #C71B30C230C2",
2549 ": c #C71B9A699658",
2550 "> c #618561856185",
2551 ", c #20811C712081",
2552 "< c #104000000000",
2553 "1 c #861720812081",
2554 "2 c #DF7D4D344103",
2555 "3 c #79E769A671C6",
2556 "4 c #861782078617",
2557 "5 c #41033CF34103",
2558 "6 c #000000000000",
2559 "7 c #49241C711040",
2560 "8 c #492445144924",
2561 "9 c #082008200820",
2562 "0 c #69A618611861",
2563 "q c #B6DA71C65144",
2564 "w c #410330C238E3",
2565 "e c #CF3CBAEAB6DA",
2566 "r c #71C6451430C2",
2567 "t c #EFBEDB6CD75C",
2568 "y c #28A208200820",
2569 "u c #186110401040",
2570 "i c #596528A21861",
2571 "p c #71C661855965",
2572 "a c #A69996589658",
2573 "s c #30C228A230C2",
2574 "d c #BEFBA289AEBA",
2575 "f c #596545145144",
2576 "g c #30C230C230C2",
2577 "h c #8E3882078617",
2578 "j c #208118612081",
2579 "k c #38E30C300820",
2580 "l c #30C2208128A2",
2581 "z c #38E328A238E3",
2582 "x c #514438E34924",
2583 "c c #618555555965",
2584 "v c #30C2208130C2",
2585 "b c #38E328A230C2",
2586 "n c #28A228A228A2",
2587 "m c #41032CB228A2",
2588 "M c #104010401040",
2589 "N c #492438E34103",
2590 "B c #28A2208128A2",
2591 "V c #A699596538E3",
2592 "C c #30C21C711040",
2593 "Z c #30C218611040",
2594 "A c #965865955965",
2595 "S c #618534D32081",
2596 "D c #38E31C711040",
2597 "F c #082000000820",
2606 "ty> 459@>+&& ",
2608 "%$;=* *3:.Xa.dfg> ",
2609 "Oh$;ya *3d.a8j,Xe.d3g8+ ",
2610 " Oh$;ka *3d$a8lz,,xxc:.e3g54 ",
2611 " Oh$;kO *pd$%svbzz,sxxxxfX..&wn> ",
2612 " Oh$@mO *3dthwlsslszjzxxxxxxx3:td8M4 ",
2613 " Oh$@g& *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B* ",
2614 " Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5& ",
2615 " Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM* ",
2616 " OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
2617 " 2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
2618 " :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
2619 " +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
2620 " *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&en",
2621 " p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
2622 " OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
2623 " 3206Bwxxszx%et.eaAp77m77mmmf3&eeeg* ",
2624 " @26MvzxNzvlbwfpdettttttttttt.c,n& ",
2625 " *;16=lsNwwNwgsvslbwwvccc3pcfu<o ",
2626 " p;<69BvwwsszslllbBlllllllu<5+ ",
2627 " OS0y6FBlvvvzvzss,u=Blllj=54 ",
2628 " c1-699Blvlllllu7k96MMMg4 ",
2629 " *10y8n6FjvllllB<166668 ",
2630 " S-kg+>666<M<996-y6n<8* ",
2631 " p71=4 m69996kD8Z-66698&& ",
2632 " &i0ycm6n4 ogk17,0<6666g ",
2633 " N-k-<> >=01-kuu666> ",
2634 " ,6ky& &46-10ul,66, ",
2635 " Ou0<> o66y<ulw<66& ",
2636 " *kk5 >66By7=xu664 ",
2637 " <<M4 466lj<Mxu66o ",
2638 " *>> +66uv,zN666* ",
2648 /* when invoked (via signal delete_event), terminates the application.
2650 void close_application( GtkWidget *widget, gpointer *data ) {
2654 int main (int argc, char *argv[])
2656 /* GtkWidget is the storage type for widgets */
2657 GtkWidget *window, *pixmap, *fixed;
2658 GdkPixmap *gdk_pixmap;
2663 /* create the main window, and attach delete_event signal to terminate
2664 the application. Note that the main window will not have a titlebar
2665 since we're making it a popup. */
2666 gtk_init (&argc, &argv);
2667 window = gtk_window_new( GTK_WINDOW_POPUP );
2668 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2669 GTK_SIGNAL_FUNC (close_application), NULL);
2670 gtk_widget_show (window);
2672 /* now for the pixmap and the pixmap widget */
2673 style = gtk_widget_get_default_style();
2674 gc = style->black_gc;
2675 gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
2676 &style->bg[GTK_STATE_NORMAL],
2677 WheelbarrowFull_xpm );
2678 pixmap = gtk_pixmap_new( gdk_pixmap, mask );
2679 gtk_widget_show( pixmap );
2681 /* To display the pixmap, we use a fixed widget to place the pixmap */
2682 fixed = gtk_fixed_new();
2683 gtk_widget_set_usize( fixed, 200, 200 );
2684 gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
2685 gtk_container_add( GTK_CONTAINER(window), fixed );
2686 gtk_widget_show( fixed );
2688 /* This masks out everything except for the image itself */
2689 gtk_widget_shape_combine_mask( window, mask, 0, 0 );
2691 /* show the window */
2692 gtk_widget_set_uposition( window, 20, 400 );
2693 gtk_widget_show( window );
2700 To make the wheelbarrow image sensitive, we could attach the button press
2701 event signal to make it do something. The following few lines would make
2702 the picture sensitive to a mouse button being pressed which makes the
2703 application terminate.
2706 gtk_widget_set_events( window,
2707 gtk_widget_get_events( window ) |
2708 GDK_BUTTON_PRESS_MASK );
2710 gtk_signal_connect( GTK_OBJECT(window), "button_press_event",
2711 GTK_SIGNAL_FUNC(close_application), NULL );
2714 <!-- ----------------------------------------------------------------- -->
2717 Ruler widgets are used to indicate the location of the mouse pointer
2718 in a given window. A window can have a vertical ruler spanning across
2719 the width and a horizontal ruler spanning down the height. A small
2720 triangular indicator on the ruler shows the exact location of the
2721 pointer relative to the ruler.
2723 A ruler must first be created. Horizontal and vertical rulers are
2727 GtkWidget *gtk_hruler_new(void); /* horizontal ruler */
2728 GtkWidget *gtk_vruler_new(void); /* vertical ruler */
2731 Once a ruler is created, we can define the unit of measurement. Units
2732 of measure for rulers can be GTK_PIXELS, GTK_INCHES or
2733 GTK_CENTIMETERS. This is set using
2736 void gtk_ruler_set_metric( GtkRuler *ruler,
2737 GtkMetricType metric );
2740 The default measure is GTK_PIXELS.
2743 gtk_ruler_set_metric( GTK_RULER(ruler), GTK_PIXELS );
2746 Other important characteristics of a ruler are how to mark the units
2747 of scale and where the position indicator is initially placed. These
2748 are set for a ruler using
2751 void gtk_ruler_set_range (GtkRuler *ruler,
2758 The lower and upper arguments define the extents of the ruler, and
2759 max_size is the largest possible number that will be displayed.
2760 Position defines the initial position of the pointer indicator within
2763 A vertical ruler can span an 800 pixel wide window thus
2766 gtk_ruler_set_range( GTK_RULER(vruler), 0, 800, 0, 800);
2769 The markings displayed on the ruler will be from 0 to 800, with
2770 a number for every 100 pixels. If instead we wanted the ruler to
2771 range from 7 to 16, we would code
2774 gtk_ruler_set_range( GTK_RULER(vruler), 7, 16, 0, 20);
2777 The indicator on the ruler is a small triangular mark that indicates
2778 the position of the pointer relative to the ruler. If the ruler is
2779 used to follow the mouse pointer, the motion_notify_event signal
2780 should be connected to the motion_notify_event method of the ruler.
2781 To follow all mouse movements within a window area, we would use
2784 #define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x
2786 gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
2787 (GtkSignalFunc)EVENT_METHOD(ruler, motion_notify_event),
2788 GTK_OBJECT(ruler) );
2791 The following example creates a drawing area with a horizontal ruler
2792 above it and a vertical ruler to the left of it. The size of the
2793 drawing area is 600 pixels wide by 400 pixels high. The horizontal
2794 ruler spans from 7 to 13 with a mark every 100 pixels, while the
2795 vertical ruler spans from 0 to 400 with a mark every 100 pixels.
2796 Placement of the drawing area and the rulers are done using a table.
2801 #include <gtk/gtk.h>
2803 #define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x
2808 /* this routine gets control when the close button is clicked
2810 void close_application( GtkWidget *widget, gpointer *data ) {
2817 int main( int argc, char *argv[] ) {
2818 GtkWidget *window, *table, *area, *hrule, *vrule;
2820 /* initialize gtk and create the main window */
2821 gtk_init( &argc, &argv );
2823 window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
2824 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2825 GTK_SIGNAL_FUNC( close_application ), NULL);
2826 gtk_container_border_width (GTK_CONTAINER (window), 10);
2828 /* create a table for placing the ruler and the drawing area */
2829 table = gtk_table_new( 3, 2, FALSE );
2830 gtk_container_add( GTK_CONTAINER(window), table );
2832 area = gtk_drawing_area_new();
2833 gtk_drawing_area_size( (GtkDrawingArea *)area, XSIZE, YSIZE );
2834 gtk_table_attach( GTK_TABLE(table), area, 1, 2, 1, 2,
2835 GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0 );
2836 gtk_widget_set_events( area, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK );
2838 /* The horizontal ruler goes on top. As the mouse moves across the drawing area,
2839 a motion_notify_event is passed to the appropriate event handler for the ruler. */
2840 hrule = gtk_hruler_new();
2841 gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
2842 gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
2843 gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
2844 (GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
2845 GTK_OBJECT(hrule) );
2846 /* GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
2847 gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
2848 GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
2850 /* The vertical ruler goes on the left. As the mouse moves across the drawing area,
2851 a motion_notify_event is passed to the appropriate event handler for the ruler. */
2852 vrule = gtk_vruler_new();
2853 gtk_ruler_set_metric( GTK_RULER(vrule), GTK_PIXELS );
2854 gtk_ruler_set_range( GTK_RULER(vrule), 0, YSIZE, 10, YSIZE );
2855 gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
2857 GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)->motion_notify_event,
2858 GTK_OBJECT(vrule) );
2859 gtk_table_attach( GTK_TABLE(table), vrule, 0, 1, 1, 2,
2860 GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0 );
2862 /* now show everything */
2863 gtk_widget_show( area );
2864 gtk_widget_show( hrule );
2865 gtk_widget_show( vrule );
2866 gtk_widget_show( table );
2867 gtk_widget_show( window );
2874 <!-- ----------------------------------------------------------------- -->
2877 Statusbars are simple widgets used to display a text message. They keep a stack
2878 of the messages pushed onto them, so that popping the current message
2879 will re-display the previous text message.
2881 In order to allow different parts of an application to use the same statusbar to display
2882 messages, the statusbar widget issues Context Identifiers which are used to identify
2883 different 'users'. The message on top of the stack is the one displayed, no matter what context
2884 it is in. Messages are stacked in last-in-first-out order, not context identifier order.
2886 A statusbar is created with a call to:
2888 GtkWidget* gtk_statusbar_new (void);
2891 A new Context Identifier is requested using a call to the following function with a short
2892 textual description of the context:
2894 guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
2895 const gchar *context_description);
2898 There are three functions that can operate on statusbars.
2900 guint gtk_statusbar_push (GtkStatusbar *statusbar,
2904 void gtk_statusbar_pop (GtkStatusbar *statusbar)
2906 void gtk_statusbar_remove (GtkStatusbar *statusbar,
2911 The first, gtk_statusbar_push, is used to add a new message to the statusbar.
2912 It returns a Message Identifier, which can be passed later to the function gtk_statusbar_remove
2913 to remove the message with the given Message and Context Identifiers from the statusbar's stack.
2915 The function gtk_statusbar_pop removes the message highest in the stack with the given
2918 The following example creates a statusbar and two buttons, one for pushing items
2919 onto the statusbar, and one for popping the last item back off.
2924 #include <gtk/gtk.h>
2927 GtkWidget *status_bar;
2929 void push_item (GtkWidget *widget, gpointer *data)
2931 static int count = 1;
2934 g_snprintf(buff, 20, "Item %d", count++);
2935 gtk_statusbar_push( GTK_STATUSBAR(status_bar), (guint) &data, buff);
2940 void pop_item (GtkWidget *widget, gpointer *data)
2942 gtk_statusbar_pop( GTK_STATUSBAR(status_bar), (guint) &data );
2946 int main (int argc, char *argv[])
2955 gtk_init (&argc, &argv);
2957 /* create a new window */
2958 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2959 gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
2960 gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
2961 gtk_signal_connect(GTK_OBJECT (window), "delete_event",
2962 (GtkSignalFunc) gtk_exit, NULL);
2964 vbox = gtk_vbox_new(FALSE, 1);
2965 gtk_container_add(GTK_CONTAINER(window), vbox);
2966 gtk_widget_show(vbox);
2968 status_bar = gtk_statusbar_new();
2969 gtk_box_pack_start (GTK_BOX (vbox), status_bar, TRUE, TRUE, 0);
2970 gtk_widget_show (status_bar);
2972 context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(status_bar), "Statusbar example");
2974 button = gtk_button_new_with_label("push item");
2975 gtk_signal_connect(GTK_OBJECT(button), "clicked",
2976 GTK_SIGNAL_FUNC (push_item), &context_id);
2977 gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
2978 gtk_widget_show(button);
2980 button = gtk_button_new_with_label("pop last item");
2981 gtk_signal_connect(GTK_OBJECT(button), "clicked",
2982 GTK_SIGNAL_FUNC (pop_item), &context_id);
2983 gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
2984 gtk_widget_show(button);
2986 /* always display the window as the last step so it all splashes on
2987 * the screen at once. */
2988 gtk_widget_show(window);
2996 <!-- ----------------------------------------------------------------- -->
2999 The Entry widget allows text to be typed and displayed in a single line text box.
3000 The text may be set with functions calls that allow new text to replace,
3001 prepend or append the current contents of the Entry widget.
3003 There are two functions for creating Entry widgets:
3005 GtkWidget* gtk_entry_new (void);
3007 GtkWidget* gtk_entry_new_with_max_length (guint16 max);
3010 The first just creates a new Entry widget, whilst the second creates a new Entry and
3011 sets a limit on the length of the text within the Entry..
3013 There are several functions for altering the text which is currently within the Entry widget.
3015 void gtk_entry_set_text (GtkEntry *entry,
3017 void gtk_entry_append_text (GtkEntry *entry,
3019 void gtk_entry_prepend_text (GtkEntry *entry,
3023 The function gtk_entry_set_text sets the contents of the Entry widget, replacing the
3024 current contents. The functions gtk_entry_append_text and gtk_entry_prepend_text allow
3025 the current contents to be appended and prepended to.
3027 The next function allows the current insertion point to be set.
3029 void gtk_entry_set_position (GtkEntry *entry,
3033 The contents of the Entry can be retrieved by using a call to the following function. This
3034 is useful in the callback functions described below.
3036 gchar* gtk_entry_get_text (GtkEntry *entry);
3039 If we don't want the contents of the Entry to be changed by someone typing into it, we
3040 can change it's edittable state.
3042 void gtk_entry_set_editable (GtkEntry *entry,
3046 This function allows us to toggle the edittable state of the Entry widget by passing in
3047 TRUE or FALSE values for the editable argument.
3049 If we are using the Entry where we don't want the text entered to be visible, for
3050 example when a password is being entered, we can use the following function, which
3051 also takes a boolean flag.
3053 void gtk_entry_set_visibility (GtkEntry *entry,
3057 A region of the text may be set as selected by using the following function. This would
3058 most often be used after setting some default text in an Entry, making it easy for the user
3061 void gtk_entry_select_region (GtkEntry *entry,
3066 If we want to catch when the user has entered text, we can connect to the
3067 <tt/activate/ or <tt/changed/ signal. Activate is raised when the user hits
3068 the enter key within the Entry widget. Changed is raised when the text changes at all,
3069 e.g. for every character entered or removed.
3071 The following code is an example of using an Entry widget.
3075 #include <gtk/gtk.h>
3077 void enter_callback(GtkWidget *widget, GtkWidget *entry)
3080 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
3081 printf("Entry contents: %s\n", entry_text);
3084 void entry_toggle_editable (GtkWidget *checkbutton,
3087 gtk_entry_set_editable(GTK_ENTRY(entry),
3088 GTK_TOGGLE_BUTTON(checkbutton)->active);
3091 void entry_toggle_visibility (GtkWidget *checkbutton,
3094 gtk_entry_set_visibility(GTK_ENTRY(entry),
3095 GTK_TOGGLE_BUTTON(checkbutton)->active);
3098 int main (int argc, char *argv[])
3102 GtkWidget *vbox, *hbox;
3107 gtk_init (&argc, &argv);
3109 /* create a new window */
3110 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
3111 gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
3112 gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
3113 gtk_signal_connect(GTK_OBJECT (window), "delete_event",
3114 (GtkSignalFunc) gtk_exit, NULL);
3116 vbox = gtk_vbox_new (FALSE, 0);
3117 gtk_container_add (GTK_CONTAINER (window), vbox);
3118 gtk_widget_show (vbox);
3120 entry = gtk_entry_new_with_max_length (50);
3121 gtk_signal_connect(GTK_OBJECT(entry), "activate",
3122 GTK_SIGNAL_FUNC(enter_callback),
3124 gtk_entry_set_text (GTK_ENTRY (entry), "hello");
3125 gtk_entry_append_text (GTK_ENTRY (entry), " world");
3126 gtk_entry_select_region (GTK_ENTRY (entry),
3127 0, GTK_ENTRY(entry)->text_length);
3128 gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
3129 gtk_widget_show (entry);
3131 hbox = gtk_hbox_new (FALSE, 0);
3132 gtk_container_add (GTK_CONTAINER (vbox), hbox);
3133 gtk_widget_show (hbox);
3135 check = gtk_check_button_new_with_label("Editable");
3136 gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
3137 gtk_signal_connect (GTK_OBJECT(check), "toggled",
3138 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
3139 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
3140 gtk_widget_show (check);
3142 check = gtk_check_button_new_with_label("Visible");
3143 gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
3144 gtk_signal_connect (GTK_OBJECT(check), "toggled",
3145 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
3146 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
3147 gtk_widget_show (check);
3149 button = gtk_button_new_with_label ("Close");
3150 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3151 GTK_SIGNAL_FUNC(gtk_exit),
3152 GTK_OBJECT (window));
3153 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3154 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3155 gtk_widget_grab_default (button);
3156 gtk_widget_show (button);
3158 gtk_widget_show(window);
3165 <!-- ----------------------------------------------------------------- -->
3166 <sect1> Color Selection
3168 The color selection widget is, not surprisingly, a widget for interactive
3169 selection of colors. This composite widget lets the user select a color by manipulating
3170 RGB (Red, Green, Blue) and HSV (Hue, Saturation, Value) triples. This is done
3171 either by adjusting single values with sliders or entries, or by picking the desired
3172 color from a hue-saturation wheel/value bar. Optionally, the opacity of the color can also
3175 The color selection widget currently emits only one signal, "color_changed", which is emitted
3176 whenever the current color in the widget changes, either when the user changes it or if
3177 it's set explicitly through gtk_color_selection_set_color().
3179 Lets have a look at what the color selection widget has to offer us. The widget comes
3180 in two flavours; gtk_color_selection and gtk_color_selection_dialog:
3183 GtkWidget *gtk_color_selection_new(void);
3186 You'll probably not be using this constructor directly. It creates an orphan
3187 GtkColorSelection widget which you'll have to parent yourself. The GtkColorSelection widget
3188 inherits from the GtkVBox widget.
3191 GtkWidget *gtk_color_selection_dialog_new(const gchar *title);
3194 This is the most common color selection constructor. It creates a GtkColorSelectionDialog, which
3195 inherits from a GtkDialog. It consists of a GtkFrame containing a GtkColorSelection widget, a
3196 GtkHSeparator and a GtkHBox with three buttons, "Ok", "Cancel" and "Help". You can reach these
3197 buttons by accessing the "ok_button", "cancel_button" and "help_button" widgets in the
3198 GtkColorSelectionDialog structure, (i.e. GTK_COLOR_SELECTION_DIALOG(colorseldialog)->ok_button).
3201 void gtk_color_selection_set_update_policy(GtkColorSelection *colorsel,
3202 GtkUpdateType policy);
3205 This function sets the update policy. The default policy is GTK_UPDATE_CONTINOUS which means that
3206 the current color is updated continously when the user drags the sliders or presses the mouse and drags
3207 in the hue-saturation wheel or value bar. If you experience performance problems, you may
3208 want to set the policy to GTK_UPDATE_DISCONTINOUS or GTK_UPDATE_DELAYED.
3211 void gtk_color_selection_set_opacity(GtkColorSelection *colorsel,
3215 The color selection widget supports adjusting the opacity of a color (also known as the alpha channel).
3216 This is disabled by default. Calling this function with use_opacity set to TRUE enables opacity.
3217 Likewise, use_opacity set to FALSE will disable opacity.
3220 void gtk_color_selection_set_color(GtkColorSelection *colorsel,
3224 You can set the current color explicitly by calling this function with a pointer to an array
3225 of colors (gdouble). The length of the array depends on whether opacity is enabled or not.
3226 Position 0 contains the red component, 1 is green, 2 is blue and opacity is at position 3 (only if
3227 opacity is enabled, see gtk_color_selection_set_opacity()). All values are between 0.0 and 1.0.
3230 void gtk_color_selection_get_color(GtkColorSelection *colorsel,
3234 When you need to query the current color, typically when you've received a "color_changed" signal,
3235 you use this function. Color is a pointer to the array of colors to fill in. See the
3236 gtk_color_selection_set_color() function for the description of this array.
3238 <!-- Need to do a whole section on DnD - TRG
3242 The color sample areas (right under the hue-saturation wheel) supports drag and drop. The type of
3243 drag and drop is "application/x-color". The message data consists of an array of 4
3244 (or 5 if opacity is enabled) gdouble values, where the value at position 0 is 0.0 (opacity
3245 on) or 1.0 (opacity off) followed by the red, green and blue values at positions 1,2 and 3 respectively.
3246 If opacity is enabled, the opacity is passed in the value at position 4.
3249 Here's a simple example demonstrating the use of the GtkColorSelectionDialog. The program displays a window
3250 containing a drawing area. Clicking on it opens a color selection dialog, and changing the color in the
3251 color selection dialog changes the background color.
3255 #include <gdk/gdk.h>
3256 #include <gtk/gtk.h>
3258 GtkWidget *colorseldlg = NULL;
3259 GtkWidget *drawingarea = NULL;
3261 /* Color changed handler */
3263 void color_changed_cb (GtkWidget *widget, GtkColorSelection *colorsel)
3267 GdkColormap *colormap;
3269 /* Get drawingarea colormap */
3271 colormap = gdk_window_get_colormap (drawingarea->window);
3273 /* Get current color */
3275 gtk_color_selection_get_color (colorsel,color);
3277 /* Fit to a unsigned 16 bit integer (0..65535) and insert into the GdkColor structure */
3279 gdk_color.red = (guint16)(color[0]*65535.0);
3280 gdk_color.green = (guint16)(color[1]*65535.0);
3281 gdk_color.blue = (guint16)(color[2]*65535.0);
3283 /* Allocate color */
3285 gdk_color_alloc (colormap, &gdk_color);
3287 /* Set window background color */
3289 gdk_window_set_background (drawingarea->window, &gdk_color);
3293 gdk_window_clear (drawingarea->window);
3296 /* Drawingarea event handler */
3298 gint area_event (GtkWidget *widget, GdkEvent *event, gpointer client_data)
3300 gint handled = FALSE;
3301 GtkWidget *colorsel;
3303 /* Check if we've received a button pressed event */
3305 if (event->type == GDK_BUTTON_PRESS && colorseldlg == NULL)
3307 /* Yes, we have an event and there's no colorseldlg yet! */
3311 /* Create color selection dialog */
3313 colorseldlg = gtk_color_selection_dialog_new("Select background color");
3315 /* Get the GtkColorSelection widget */
3317 colorsel = GTK_COLOR_SELECTION_DIALOG(colorseldlg)->colorsel;
3319 /* Connect to the "color_changed" signal, set the client-data to the colorsel widget */
3321 gtk_signal_connect(GTK_OBJECT(colorsel), "color_changed",
3322 (GtkSignalFunc)color_changed_cb, (gpointer)colorsel);
3324 /* Show the dialog */
3326 gtk_widget_show(colorseldlg);
3332 /* Close down and exit handler */
3334 void destroy_window (GtkWidget *widget, gpointer client_data)
3341 gint main (gint argc, gchar *argv[])
3345 /* Initialize the toolkit, remove gtk-related commandline stuff */
3347 gtk_init (&argc,&argv);
3349 /* Create toplevel window, set title and policies */
3351 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3352 gtk_window_set_title (GTK_WINDOW(window), "Color selection test");
3353 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, TRUE);
3355 /* Attach to the "delete" and "destroy" events so we can exit */
3357 gtk_signal_connect (GTK_OBJECT(window), "delete_event",
3358 (GtkSignalFunc)destroy_window, (gpointer)window);
3360 gtk_signal_connect (GTK_OBJECT(window), "destroy",
3361 (GtkSignalFunc)destroy_window, (gpointer)window);
3363 /* Create drawingarea, set size and catch button events */
3365 drawingarea = gtk_drawing_area_new ();
3367 gtk_drawing_area_size (GTK_DRAWING_AREA(drawingarea), 200, 200);
3369 gtk_widget_set_events (drawingarea, GDK_BUTTON_PRESS_MASK);
3371 gtk_signal_connect (GTK_OBJECT(drawingarea), "event",
3372 (GtkSignalFunc)area_event, (gpointer)drawingarea);
3374 /* Add drawingarea to window, then show them both */
3376 gtk_container_add (GTK_CONTAINER(window), drawingarea);
3378 gtk_widget_show (drawingarea);
3379 gtk_widget_show (window);
3381 /* Enter the gtk main loop (this never returns) */
3385 /* Satisfy grumpy compilers */
3390 <!-- ----------------------------------------------------------------- -->
3391 <sect1> File Selections
3393 The file selection widget is a quick and simple way to display a File
3394 dialog box. It comes complete with Ok, Cancel, and Help buttons, a great way
3395 to cut down on programming time.
3397 To create a new file selection box use:
3400 GtkWidget* gtk_file_selection_new (gchar *title);
3403 To set the filename, for example to bring up a specific directory, or
3404 give a default filename, use this function:
3407 void gtk_file_selection_set_filename (GtkFileSelection *filesel, gchar *filename);
3410 To grab the text that the user has entered or clicked on, use this
3414 gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel);
3417 There are also pointers to the widgets contained within the file
3418 selection widget. These are:
3423 <item>selection_entry
3424 <item>selection_text
3431 Most likely you will want to use the ok_button, cancel_button, and
3432 help_button pointers in signaling their use.
3434 Included here is an example stolen from testgtk.c, modified to run
3435 on it's own. As you will see, there is nothing much to creating a file
3436 selection widget. While, in this example, the Help button appears on the
3437 screen, it does nothing as there is not a signal attached to it.
3442 #include <gtk/gtk.h>
3444 /* Get the selected filename and print it to the console */
3445 void file_ok_sel (GtkWidget *w, GtkFileSelection *fs)
3447 g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
3450 void destroy (GtkWidget *widget, gpointer *data)
3455 int main (int argc, char *argv[])
3459 gtk_init (&argc, &argv);
3461 /* Create a new file selection widget */
3462 filew = gtk_file_selection_new ("File selection");
3464 gtk_signal_connect (GTK_OBJECT (filew), "destroy",
3465 (GtkSignalFunc) destroy, &filew);
3466 /* Connect the ok_button to file_ok_sel function */
3467 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
3468 "clicked", (GtkSignalFunc) file_ok_sel, filew );
3470 /* Connect the cancel_button to destroy the widget */
3471 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
3472 "clicked", (GtkSignalFunc) gtk_widget_destroy,
3473 GTK_OBJECT (filew));
3475 /* Lets set the filename, as if this were a save dialog, and we are giving
3476 a default filename */
3477 gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew),
3480 gtk_widget_show(filew);
3486 <!-- ***************************************************************** -->
3487 <sect> Container Widgets
3488 <!-- ***************************************************************** -->
3490 <!-- ----------------------------------------------------------------- -->
3493 The NoteBook Widget is a collection of 'pages' that overlap each other,
3494 each page contains different information. This widget has become more common
3495 lately in GUI programming, and it is a good way to show blocks similar
3496 information that warrant separation in their display.
3498 The first function call you will need to know, as you can probably
3499 guess by now, is used to create a new notebook widget.
3502 GtkWidget* gtk_notebook_new (void);
3505 Once the notebook has been created, there are 12 functions that
3506 operate on the notebook widget. Let's look at them individually.
3508 The first one we will look at is how to position the page indicators.
3509 These page indicators or 'tabs' as they are referred to, can be positioned
3510 in four ways; top, bottom, left, or right.
3513 void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos);
3516 GtkPostionType will be one of the following, and they are pretty self explanatory.
3519 <item> GTK_POS_RIGHT
3521 <item> GTK_POS_BOTTOM
3524 GTK_POS_TOP is the default.
3526 Next we will look at how to add pages to the notebook. There are three
3527 ways to add pages to the NoteBook. Let's look at the first two together as
3528 they are quite similar.
3531 void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
3533 void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
3536 These functions add pages to the notebook by inserting them from the
3537 back of the notebook (append), or the front of the notebook (prepend).
3538 *child is the widget that is placed within the notebook page, and *tab_label is
3539 the label for the page being added.
3541 The final function for adding a page to the notebook contains all of
3542 the properties of the previous two, but it allows you to specify what position
3543 you want the page to be in the notebook.
3546 void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, gint position);
3549 The parameters are the same as _append_ and _prepend_ except it
3550 contains an extra parameter, position. This parameter is used to specify what
3551 place this page will inserted to.
3553 Now that we know how to add a page, lets see how we can remove a page
3557 void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num);
3560 This function takes the page specified by page_num and removes it from
3561 the widget *notebook.
3563 To find out what the current page is in a notebook use the function:
3566 gint gtk_notebook_current_page (GtkNotebook *notebook);
3569 These next two functions are simple calls to move the notebook page
3570 forward or backward. Simply provide the respective function call with the
3571 notebook widget you wish to operate on. Note: When the NoteBook is currently
3572 on the last page, and gtk_notebook_next_page is called, the notebook will
3573 wrap back to the first page. Likewise, if the NoteBook is on the first page,
3574 and gtk_notebook_prev_page is called, the notebook will wrap to the last page.
3577 void gtk_notebook_next_page (GtkNoteBook *notebook);
3578 void gtk_notebook_prev_page (GtkNoteBook *notebook);
3581 This next function sets the 'active' page. If you wish the
3582 notebook to be opened to page 5 for example, you would use this function.
3583 Without using this function, the notebook defaults to the first page.
3586 void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num);
3589 The next two functions add or remove the notebook page tabs and the
3590 notebook border respectively.
3593 void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs);
3594 void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border);
3597 show_tabs and show_border can both be either TRUE or FALSE (0 or 1).
3599 Now lets look at an example, it is expanded from the testgtk.c code
3600 that comes with the GTK distribution, and it shows all 13 functions. This
3601 small program, creates a window with a notebook and six buttons. The notebook
3602 contains 11 pages, added in three different ways, appended, inserted, and
3603 prepended. The buttons allow you rotate the tab positions, add/remove the tabs
3604 and border, remove a page, change pages in both a forward and backward manner,
3605 and exit the program.
3610 #include <gtk/gtk.h>
3612 /* This function rotates the position of the tabs */
3613 void rotate_book (GtkButton *button, GtkNotebook *notebook)
3615 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
3618 /* Add/Remove the page tabs and the borders */
3619 void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
3623 if (notebook->show_tabs == 0)
3625 if (notebook->show_border == 0)
3628 gtk_notebook_set_show_tabs (notebook, tval);
3629 gtk_notebook_set_show_border (notebook, bval);
3632 /* Remove a page from the notebook */
3633 void remove_book (GtkButton *button, GtkNotebook *notebook)
3637 page = gtk_notebook_current_page(notebook);
3638 gtk_notebook_remove_page (notebook, page);
3639 /* Need to refresh the widget --
3640 This forces the widget to redraw itself. */
3641 gtk_widget_draw(GTK_WIDGET(notebook), NULL);
3644 void delete (GtkWidget *widget, gpointer *data)
3649 int main (int argc, char *argv[])
3654 GtkWidget *notebook;
3657 GtkWidget *checkbutton;
3662 gtk_init (&argc, &argv);
3664 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3666 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3667 GTK_SIGNAL_FUNC (delete), NULL);
3669 gtk_container_border_width (GTK_CONTAINER (window), 10);
3671 table = gtk_table_new(2,6,TRUE);
3672 gtk_container_add (GTK_CONTAINER (window), table);
3674 /* Create a new notebook, place the position of the tabs */
3675 notebook = gtk_notebook_new ();
3676 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
3677 gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
3678 gtk_widget_show(notebook);
3680 /* lets append a bunch of pages to the notebook */
3681 for (i=0; i < 5; i++) {
3682 sprintf(bufferf, "Append Frame %d", i+1);
3683 sprintf(bufferl, "Page %d", i+1);
3685 frame = gtk_frame_new (bufferf);
3686 gtk_container_border_width (GTK_CONTAINER (frame), 10);
3687 gtk_widget_set_usize (frame, 100, 75);
3688 gtk_widget_show (frame);
3690 label = gtk_label_new (bufferf);
3691 gtk_container_add (GTK_CONTAINER (frame), label);
3692 gtk_widget_show (label);
3694 label = gtk_label_new (bufferl);
3695 gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
3699 /* now lets add a page to a specific spot */
3700 checkbutton = gtk_check_button_new_with_label ("Check me please!");
3701 gtk_widget_set_usize(checkbutton, 100, 75);
3702 gtk_widget_show (checkbutton);
3704 label = gtk_label_new ("Add spot");
3705 gtk_container_add (GTK_CONTAINER (checkbutton), label);
3706 gtk_widget_show (label);
3707 label = gtk_label_new ("Add page");
3708 gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
3710 /* Now finally lets prepend pages to the notebook */
3711 for (i=0; i < 5; i++) {
3712 sprintf(bufferf, "Prepend Frame %d", i+1);
3713 sprintf(bufferl, "PPage %d", i+1);
3715 frame = gtk_frame_new (bufferf);
3716 gtk_container_border_width (GTK_CONTAINER (frame), 10);
3717 gtk_widget_set_usize (frame, 100, 75);
3718 gtk_widget_show (frame);
3720 label = gtk_label_new (bufferf);
3721 gtk_container_add (GTK_CONTAINER (frame), label);
3722 gtk_widget_show (label);
3724 label = gtk_label_new (bufferl);
3725 gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
3728 /* Set what page to start at (page 4) */
3729 gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
3732 /* create a bunch of buttons */
3733 button = gtk_button_new_with_label ("close");
3734 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3735 GTK_SIGNAL_FUNC (delete), NULL);
3736 gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
3737 gtk_widget_show(button);
3739 button = gtk_button_new_with_label ("next page");
3740 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3741 (GtkSignalFunc) gtk_notebook_next_page,
3742 GTK_OBJECT (notebook));
3743 gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
3744 gtk_widget_show(button);
3746 button = gtk_button_new_with_label ("prev page");
3747 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3748 (GtkSignalFunc) gtk_notebook_prev_page,
3749 GTK_OBJECT (notebook));
3750 gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
3751 gtk_widget_show(button);
3753 button = gtk_button_new_with_label ("tab position");
3754 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3755 (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
3756 gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
3757 gtk_widget_show(button);
3759 button = gtk_button_new_with_label ("tabs/border on/off");
3760 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3761 (GtkSignalFunc) tabsborder_book,
3762 GTK_OBJECT (notebook));
3763 gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
3764 gtk_widget_show(button);
3766 button = gtk_button_new_with_label ("remove page");
3767 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3768 (GtkSignalFunc) remove_book,
3769 GTK_OBJECT(notebook));
3770 gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
3771 gtk_widget_show(button);
3773 gtk_widget_show(table);
3774 gtk_widget_show(window);
3782 Hopefully this helps you on your way with creating notebooks for your
3785 <!-- ----------------------------------------------------------------- -->
3786 <sect1> Scrolled Windows
3788 Scrolled windows are used to create a scrollable area inside a real window.
3789 You may insert any types of widgets to these scrolled windows, and they will
3790 all be accessable regardless of the size by using the scrollbars.
3792 The following function is used to create a new scolled window.
3795 GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
3796 GtkAdjustment *vadjustment);
3799 Where the first argument is the adjustment for the horizontal
3800 direction, and the second, the adjustment for the vertical direction.
3801 These are almost always set to NULL.
3804 void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
3805 GtkPolicyType hscrollbar_policy,
3806 GtkPolicyType vscrollbar_policy);
3809 This sets the policy to be used with respect to the scrollbars.
3810 The first arguement is the scrolled window you wish to change. The second
3811 sets the policiy for the horizontal scrollbar, and the third,
3812 the vertical scrollbar.
3814 The policy may be one of GTK_POLICY AUTOMATIC, or GTK_POLICY_ALWAYS.
3815 GTK_POLICY_AUTOMATIC will automatically decide whether you need
3816 scrollbars, wheras GTK_POLICY_ALWAYS will always leave the scrollbars
3819 Here is a simple example that packs 100 toggle buttons into a scrolled window.
3820 I've only commented on the parts that may be new to you.
3825 #include <gtk/gtk.h>
3827 void destroy(GtkWidget *widget, gpointer *data)
3832 int main (int argc, char *argv[])
3834 static GtkWidget *window;
3835 GtkWidget *scrolled_window;
3841 gtk_init (&argc, &argv);
3843 /* Create a new dialog window for the scrolled window to be
3844 * packed into. A dialog is just like a normal window except it has a
3845 * vbox and a horizontal seperator packed into it. It's just a shortcut
3846 * for creating dialogs */
3847 window = gtk_dialog_new ();
3848 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3849 (GtkSignalFunc) destroy, NULL);
3850 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3851 gtk_container_border_width (GTK_CONTAINER (window), 0);
3852 gtk_widget_set_usize(window, 300, 300);
3854 /* create a new scrolled window. */
3855 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3857 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
3859 /* the policy is one of GTK_POLICY AUTOMATIC, or GTK_POLICY_ALWAYS.
3860 * GTK_POLICY_AUTOMATIC will automatically decide whether you need
3861 * scrollbars, wheras GTK_POLICY_ALWAYS will always leave the scrollbars
3862 * there. The first one is the horizontal scrollbar, the second,
3864 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3865 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3866 /* The dialog window is created with a vbox packed into it. */
3867 gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window,
3869 gtk_widget_show (scrolled_window);
3871 /* create a table of 10 by 10 squares. */
3872 table = gtk_table_new (10, 10, FALSE);
3874 /* set the spacing to 10 on x and 10 on y */
3875 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
3876 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
3878 /* pack the table into the scrolled window */
3879 gtk_container_add (GTK_CONTAINER (scrolled_window), table);
3880 gtk_widget_show (table);
3882 /* this simply creates a grid of toggle buttons on the table
3883 * to demonstrate the scrolled window. */
3884 for (i = 0; i < 10; i++)
3885 for (j = 0; j < 10; j++) {
3886 sprintf (buffer, "button (%d,%d)\n", i, j);
3887 button = gtk_toggle_button_new_with_label (buffer);
3888 gtk_table_attach_defaults (GTK_TABLE (table), button,
3890 gtk_widget_show (button);
3893 /* Add a "close" button to the bottom of the dialog */
3894 button = gtk_button_new_with_label ("close");
3895 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3896 (GtkSignalFunc) gtk_widget_destroy,
3897 GTK_OBJECT (window));
3899 /* this makes it so the button is the default. */
3901 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3902 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
3904 /* This grabs this button to be the default button. Simply hitting
3905 * the "Enter" key will cause this button to activate. */
3906 gtk_widget_grab_default (button);
3907 gtk_widget_show (button);
3909 gtk_widget_show (window);
3917 Try playing with resizing the window. You'll notice how the scrollbars
3918 react. You may also wish to use the gtk_widget_set_usize() call to set the default
3919 size of the window or other widgets.
3921 <!-- ----------------------------------------------------------------- -->
3922 <sect1> Paned Window Widgets
3924 The paned window widgets are useful when you want to divide an area
3925 into two parts, with the relative size of the two parts controlled by
3926 the user. A groove is drawn between the two portions with a handle
3927 that the user can drag to change the ratio. The division can either
3928 be horizontal (HPaned) or vertical (VPaned).
3930 To create a new paned window, call one of:
3933 GtkWidget* gtk_hpaned_new (void)
3934 GtkWidget* gtk_vpaned_new (void)
3937 After creating the paned window widget, you need to add child widgets
3938 to its two halves. To do this, use the functions:
3941 void gtk_paned_add1 (GtkPaned *paned, GtkWidget *child)
3942 void gtk_paned_add2 (GtkPaned *paned, GtkWidget *child)
3945 <tt/gtk_paned_add1()/ adds the child widget to the left or top half of
3946 the paned window. <tt/gtk_paned_add2()/ adds the child widget to the
3947 right or bottom half of the paned window.
3949 As an example, we will create part of the user interface of an
3950 imaginary email program. A window is divided into two portions
3951 vertically, with the top portion being a list of email messages and
3952 the bottom portion the text of the email message. Most of the program
3953 is pretty straightforward. A couple of points to note are: Text can't
3954 be added to a Text widget until it is realized. This could be done by
3955 calling <tt/gtk_widget_realize()/, but as a demonstration of an alternate
3956 technique, we connect a handler to the "realize" signal to add the
3957 text. Also, we need to add the <tt/GTK_SHRINK/ option to some of the
3958 items in the table containing the text window and its scrollbars, so
3959 that when the bottom portion is made smaller, the correct portions
3960 shrink instead of being pushed off the bottom of the window.
3965 #include <gtk/gtk.h>
3967 /* Create the list of "messages" */
3972 GtkWidget *scrolled_window;
3974 GtkWidget *list_item;
3979 /* Create a new scrolled window, with scrollbars only if needed */
3980 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3981 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3982 GTK_POLICY_AUTOMATIC,
3983 GTK_POLICY_AUTOMATIC);
3985 /* Create a new list and put it in the scrolled window */
3986 list = gtk_list_new ();
3987 gtk_container_add (GTK_CONTAINER(scrolled_window), list);
3988 gtk_widget_show (list);
3990 /* Add some messages to the window */
3991 for (i=0; i<10; i++) {
3993 sprintf(buffer,"Message #%d",i);
3994 list_item = gtk_list_item_new_with_label (buffer);
3995 gtk_container_add (GTK_CONTAINER(list), list_item);
3996 gtk_widget_show (list_item);
4000 return scrolled_window;
4003 /* Add some text to our text widget - this is a callback that is invoked
4004 when our window is realized. We could also force our window to be
4005 realized with gtk_widget_realize, but it would have to be part of
4006 a hierarchy first */
4009 realize_text (GtkWidget *text, gpointer data)
4011 gtk_text_freeze (GTK_TEXT (text));
4012 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4013 "From: pathfinder@nasa.gov\n"
4014 "To: mom@nasa.gov\n"
4015 "Subject: Made it!\n"
4017 "We just got in this morning. The weather has been\n"
4018 "great - clear but cold, and there are lots of fun sights.\n"
4019 "Sojourner says hi. See you soon.\n"
4022 gtk_text_thaw (GTK_TEXT (text));
4025 /* Create a scrolled text area that displays a "message" */
4031 GtkWidget *hscrollbar;
4032 GtkWidget *vscrollbar;
4034 /* Create a table to hold the text widget and scrollbars */
4035 table = gtk_table_new (2, 2, FALSE);
4037 /* Put a text widget in the upper left hand corner. Note the use of
4038 * GTK_SHRINK in the y direction */
4039 text = gtk_text_new (NULL, NULL);
4040 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
4041 GTK_FILL | GTK_EXPAND,
4042 GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
4043 gtk_widget_show (text);
4045 /* Put a HScrollbar in the lower left hand corner */
4046 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
4047 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
4048 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
4049 gtk_widget_show (hscrollbar);
4051 /* And a VScrollbar in the upper right */
4052 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
4053 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
4054 GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
4055 gtk_widget_show (vscrollbar);
4057 /* Add a handler to put a message in the text widget when it is realized */
4058 gtk_signal_connect (GTK_OBJECT (text), "realize",
4059 GTK_SIGNAL_FUNC (realize_text), NULL);
4065 main (int argc, char *argv[])
4072 gtk_init (&argc, &argv);
4074 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4075 gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
4076 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4077 GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
4078 gtk_container_border_width (GTK_CONTAINER (window), 10);
4080 /* create a vpaned widget and add it to our toplevel window */
4082 vpaned = gtk_vpaned_new ();
4083 gtk_container_add (GTK_CONTAINER(window), vpaned);
4084 gtk_widget_show (vpaned);
4086 /* Now create the contents of the two halves of the window */
4088 list = create_list ();
4089 gtk_paned_add1 (GTK_PANED(vpaned), list);
4090 gtk_widget_show (list);
4092 text = create_text ();
4093 gtk_paned_add2 (GTK_PANED(vpaned), text);
4094 gtk_widget_show (text);
4095 gtk_widget_show (window);
4102 <!-- ----------------------------------------------------------------- -->
4103 <sect1> Aspect Frames
4105 The aspect frame widget is like a frame widget, except that it also
4106 enforces the aspect ratio (that is, the ratio of the width to the
4107 height) of the child widget to have a certain value, adding extra
4108 space if necessary. This is useful, for instance, if you want to
4109 preview a larger image. The size of the preview should vary when
4110 the user resizes the window, but the aspect ratio needs to always match
4113 To create a new aspect frame, use:
4116 GtkWidget* gtk_aspect_frame_new (const gchar *label,
4123 <tt/xalign/ and <tt/yalign/ specifiy alignment as with Alignment
4124 widgets. If <tt/obey_child/ is true, the aspect ratio of a child
4125 widget will match the aspect ratio of the ideal size it requests.
4126 Otherwise, it is given by <tt/ratio/.
4128 To change the options of an existing aspect frame, you can use:
4131 void gtk_aspect_frame_set (GtkAspectFrame *aspect_frame,
4139 As an example, the following program uses an AspectFrame to
4140 present a drawing area whose aspect ratio will always be 2:1, no
4141 matter how the user resizes the top-level window.
4146 #include <gtk/gtk.h>
4149 main (int argc, char *argv[])
4152 GtkWidget *aspect_frame;
4153 GtkWidget *drawing_area;
4154 gtk_init (&argc, &argv);
4156 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4157 gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
4158 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4159 GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
4160 gtk_container_border_width (GTK_CONTAINER (window), 10);
4162 /* Create an aspect_frame and add it to our toplevel window */
4164 aspect_frame = gtk_aspect_frame_new ("2x1", /* label */
4167 2, /* xsize/ysize = 2 */
4168 FALSE /* ignore child's aspect */);
4170 gtk_container_add (GTK_CONTAINER(window), aspect_frame);
4171 gtk_widget_show (aspect_frame);
4173 /* Now add a child widget to the aspect frame */
4175 drawing_area = gtk_drawing_area_new ();
4177 /* Ask for a 200x200 window, but the AspectFrame will give us a 200x100
4178 * window since we are forcing a 2x1 aspect ratio */
4179 gtk_widget_set_usize (drawing_area, 200, 200);
4180 gtk_container_add (GTK_CONTAINER(aspect_frame), drawing_area);
4181 gtk_widget_show (drawing_area);
4183 gtk_widget_show (window);
4189 <!-- ***************************************************************** -->
4191 <!-- ***************************************************************** -->
4194 The GtkList widget is designed to act as a vertical container for widgets
4195 that should be of the type GtkListItem.
4197 A GtkList widget has its own window to receive events and it's own
4198 background color which is usualy white. As it is directly derived from a
4199 GtkContainer it can be treated as such by using the GTK_CONTAINER(List)
4200 macro, see the GtkContainer widget for more on this.
4201 One should already be familar whith the usage of a GList and its
4202 related functions g_list_*() to be able to use the GtkList widget to
4205 There is one field inside the structure definition of the GtkList widget
4206 that will be of greater interest to us, this is:
4213 guint selection_mode;
4218 The selection field of a GtkList points to a linked list of all items
4219 that are cureently selected, or `NULL' if the selection is empty.
4220 So to learn about the current selection we read the GTK_LIST()->selection
4221 field, but do not modify it since the internal fields are maintained by
4222 the gtk_list_*() functions.
4224 The selection_mode of the GtkList determines the selection facilities
4225 of a GtkList and therefore the contents of the GTK_LIST()->selection
4228 The selection_mode may be one of the following:
4230 <item> GTK_SELECTION_SINGLE - The selection is either `NULL'
4231 or contains a GList* pointer
4232 for a single selected item.
4234 <item> GTK_SELECTION_BROWSE - The selection is `NULL' if the list
4235 contains no widgets or insensitive
4236 ones only, otherwise it contains
4237 a GList pointer for one GList
4238 structure, and therefore exactly
4241 <item> GTK_SELECTION_MULTIPLE - The selection is `NULL' if no list
4242 items are selected or a GList pointer
4243 for the first selected item. That
4244 in turn points to a GList structure
4245 for the second selected item and so
4248 <item> GTK_SELECTION_EXTENDED - The selection is always `NULL'.
4251 The default is GTK_SELECTION_MULTIPLE.
4253 <!-- ----------------------------------------------------------------- -->
4257 void selection_changed (GtkList *LIST)
4260 This signal will be invoked whenever a the selection field
4261 of a GtkList has changed. This happens when a child of
4262 the GtkList got selected or unselected.
4265 void select_child (GtkList *LIST, GtkWidget *CHILD)
4268 This signal is invoked when a child of the GtkList is about
4269 to get selected. This happens mainly on calls to
4270 gtk_list_select_item(), gtk_list_select_child(), button presses
4271 and sometimes indirectly triggered on some else occasions where
4272 children get added to or removed from the GtkList.
4275 void unselect_child (GtkList *LIST, GtkWidget *CHILD)
4278 This signal is invoked when a child of the GtkList is about
4279 to get unselected. This happens mainly on calls to
4280 gtk_list_unselect_item(), gtk_list_unselect_child(), button presses
4281 and sometimes indirectly triggered on some else occasions where
4282 children get added to or removed from the GtkList.
4284 <!-- ----------------------------------------------------------------- -->
4288 guint gtk_list_get_type (void)
4291 Returns the `GtkList' type identifier.
4294 GtkWidget* gtk_list_new (void)
4297 Create a new `GtkList' object. The new widget is
4298 returned as a pointer to a `GtkWidget' object.
4299 `NULL' is returned on failure.
4302 void gtk_list_insert_items (GtkList *LIST, GList *ITEMS, gint POSITION)
4305 Insert list items into the LIST, starting at POSITION.
4306 ITEMS is a doubly linked list where each nodes data
4307 pointer is expected to point to a newly created GtkListItem.
4308 The GList nodes of ITEMS are taken over by the LIST.
4311 void gtk_list_append_items (GtkList *LIST, GList *ITEMS)
4314 Insert list items just like gtk_list_insert_items() at the end
4315 of the LIST. The GList nodes of ITEMS are taken over by the LIST.
4318 void gtk_list_prepend_items (GtkList *LIST, GList *ITEMS)
4321 Insert list items just like gtk_list_insert_items() at the very
4322 beginning of the LIST. The GList nodes of ITEMS are taken over
4326 void gtk_list_remove_items (GtkList *LIST, GList *ITEMS)
4329 Remove list items from the LIST. ITEMS is a doubly linked
4330 list where each nodes data pointer is expected to point to a
4331 direct child of LIST. It is the callers responsibility to make a
4332 call to g_list_free(ITEMS) afterwards. Also the caller has to
4333 destroy the list items himself.
4336 void gtk_list_clear_items (GtkList *LIST, gint START, gint END)
4339 Remove and destroy list items from the LIST. a widget is affected if
4340 its current position within LIST is in the range specified by START
4344 void gtk_list_select_item (GtkList *LIST, gint ITEM)
4347 Invoke the select_child signal for a list item
4348 specified through its current position within LIST.
4351 void gtk_list_unselect_item (GtkList *LIST, gint ITEM)
4354 Invoke the unselect_child signal for a list item
4355 specified through its current position within LIST.
4358 void gtk_list_select_child (GtkList *LIST, GtkWidget *CHILD)
4361 Invoke the select_child signal for the specified CHILD.
4364 void gtk_list_unselect_child (GtkList *LIST, GtkWidget *CHILD)
4367 Invoke the unselect_child signal for the specified CHILD.
4370 gint gtk_list_child_position (GtkList *LIST, GtkWidget *CHILD)
4373 Return the position of CHILD within LIST. `-1' is returned on failure.
4376 void gtk_list_set_selection_mode (GtkList *LIST, GtkSelectionMode MODE)
4379 Set LIST to the selection mode MODE wich can be of GTK_SELECTION_SINGLE,
4380 GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE or GTK_SELECTION_EXTENDED.
4383 GtkList* GTK_LIST (gpointer OBJ)
4386 Cast a generic pointer to `GtkList*'. *Note Standard Macros::, for
4390 GtkListClass* GTK_LIST_CLASS (gpointer CLASS)
4393 Cast a generic pointer to `GtkListClass*'. *Note Standard Macros::,
4397 gint GTK_IS_LIST (gpointer OBJ)
4400 Determine if a generic pointer refers to a `GtkList' object. *Note
4401 Standard Macros::, for more info.
4403 <!-- ----------------------------------------------------------------- -->
4406 Following is an example program that will print out the changes
4407 of the selection of a GtkList, and lets you "arrest" list items
4408 into a prison by selecting them with the rightmost mouse button:
4413 /* include the gtk+ header files
4414 * include stdio.h, we need that for the printf() function
4416 #include <gtk/gtk.h>
4419 /* this is our data identification string to store
4420 * data in list items
4422 const gchar *list_item_data_key="list_item_data";
4425 /* prototypes for signal handler that we are going to connect
4426 * to the GtkList widget
4428 static void sigh_print_selection (GtkWidget *gtklist,
4429 gpointer func_data);
4430 static void sigh_button_event (GtkWidget *gtklist,
4431 GdkEventButton *event,
4435 /* main function to set up the user interface */
4437 gint main (int argc, gchar *argv[])
4439 GtkWidget *separator;
4442 GtkWidget *scrolled_window;
4446 GtkWidget *list_item;
4452 /* initialize gtk+ (and subsequently gdk) */
4454 gtk_init(&argc, &argv);
4457 /* create a window to put all the widgets in
4458 * connect gtk_main_quit() to the "destroy" event of
4459 * the window to handle window manager close-window-events
4461 window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
4462 gtk_window_set_title(GTK_WINDOW(window), "GtkList Example");
4463 gtk_signal_connect(GTK_OBJECT(window),
4465 GTK_SIGNAL_FUNC(gtk_main_quit),
4469 /* inside the window we need a box to arrange the widgets
4471 vbox=gtk_vbox_new(FALSE, 5);
4472 gtk_container_border_width(GTK_CONTAINER(vbox), 5);
4473 gtk_container_add(GTK_CONTAINER(window), vbox);
4474 gtk_widget_show(vbox);
4476 /* this is the scolled window to put the GtkList widget inside */
4477 scrolled_window=gtk_scrolled_window_new(NULL, NULL);
4478 gtk_widget_set_usize(scrolled_window, 250, 150);
4479 gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
4480 gtk_widget_show(scrolled_window);
4482 /* create the GtkList widget
4483 * connect the sigh_print_selection() signal handler
4484 * function to the "selection_changed" signal of the GtkList
4485 * to print out the selected items each time the selection
4487 gtklist=gtk_list_new();
4488 gtk_container_add(GTK_CONTAINER(scrolled_window), gtklist);
4489 gtk_widget_show(gtklist);
4490 gtk_signal_connect(GTK_OBJECT(gtklist),
4491 "selection_changed",
4492 GTK_SIGNAL_FUNC(sigh_print_selection),
4495 /* we create a "Prison" to put a list item in ;)
4497 frame=gtk_frame_new("Prison");
4498 gtk_widget_set_usize(frame, 200, 50);
4499 gtk_container_border_width(GTK_CONTAINER(frame), 5);
4500 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
4501 gtk_container_add(GTK_CONTAINER(vbox), frame);
4502 gtk_widget_show(frame);
4504 /* connect the sigh_button_event() signal handler to the GtkList
4505 * wich will handle the "arresting" of list items
4507 gtk_signal_connect(GTK_OBJECT(gtklist),
4508 "button_release_event",
4509 GTK_SIGNAL_FUNC(sigh_button_event),
4512 /* create a separator
4514 separator=gtk_hseparator_new();
4515 gtk_container_add(GTK_CONTAINER(vbox), separator);
4516 gtk_widget_show(separator);
4518 /* finaly create a button and connect it´s "clicked" signal
4519 * to the destroyment of the window
4521 button=gtk_button_new_with_label("Close");
4522 gtk_container_add(GTK_CONTAINER(vbox), button);
4523 gtk_widget_show(button);
4524 gtk_signal_connect_object(GTK_OBJECT(button),
4526 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4527 GTK_OBJECT(window));
4530 /* now we create 5 list items, each having it´s own
4531 * label and add them to the GtkList using gtk_container_add()
4532 * also we query the text string from the label and
4533 * associate it with the list_item_data_key for each list item
4535 for (i=0; i<5; i++) {
4539 sprintf(buffer, "ListItemContainer with Label #%d", i);
4540 label=gtk_label_new(buffer);
4541 list_item=gtk_list_item_new();
4542 gtk_container_add(GTK_CONTAINER(list_item), label);
4543 gtk_widget_show(label);
4544 gtk_container_add(GTK_CONTAINER(gtklist), list_item);
4545 gtk_widget_show(list_item);
4546 gtk_label_get(GTK_LABEL(label), &string);
4547 gtk_object_set_data(GTK_OBJECT(list_item),
4551 /* here, we are creating another 5 labels, this time
4552 * we use gtk_list_item_new_with_label() for the creation
4553 * we can´t query the text string from the label because
4554 * we don´t have the labels pointer and therefore
4555 * we just associate the list_item_data_key of each
4556 * list item with the same text string
4557 * for adding of the list items we put them all into a doubly
4558 * linked list (GList), and then add them by a single call to
4559 * gtk_list_append_items()
4560 * because we use g_list_prepend() to put the items into the
4561 * doubly linked list, their order will be descending (instead
4562 * of ascending when using g_list_append())
4566 sprintf(buffer, "List Item with Label %d", i);
4567 list_item=gtk_list_item_new_with_label(buffer);
4568 dlist=g_list_prepend(dlist, list_item);
4569 gtk_widget_show(list_item);
4570 gtk_object_set_data(GTK_OBJECT(list_item),
4572 "ListItem with integrated Label");
4574 gtk_list_append_items(GTK_LIST(gtklist), dlist);
4576 /* finaly we want to see the window, don´t we? ;)
4578 gtk_widget_show(window);
4580 /* fire up the main event loop of gtk
4584 /* we get here after gtk_main_quit() has been called which
4585 * happens if the main window gets destroyed
4590 /* this is the signal handler that got connected to button
4591 * press/release events of the GtkList
4594 sigh_button_event (GtkWidget *gtklist,
4595 GdkEventButton *event,
4598 /* we only do something if the third (rightmost mouse button
4601 if (event->type==GDK_BUTTON_RELEASE &&
4603 GList *dlist, *free_list;
4604 GtkWidget *new_prisoner;
4606 /* fetch the currently selected list item which
4607 * will be our next prisoner ;)
4609 dlist=GTK_LIST(gtklist)->selection;
4611 new_prisoner=GTK_WIDGET(dlist->data);
4615 /* look for already prisoned list items, we
4616 * will put them back into the list
4617 * remember to free the doubly linked list that
4618 * gtk_container_children() returns
4620 dlist=gtk_container_children(GTK_CONTAINER(frame));
4623 GtkWidget *list_item;
4625 list_item=dlist->data;
4627 gtk_widget_reparent(list_item, gtklist);
4631 g_list_free(free_list);
4633 /* if we have a new prisoner, remove him from the
4634 * GtkList and put him into the frame "Prison"
4635 * we need to unselect the item before
4640 static_dlist.data=new_prisoner;
4641 static_dlist.next=NULL;
4642 static_dlist.prev=NULL;
4644 gtk_list_unselect_child(GTK_LIST(gtklist),
4646 gtk_widget_reparent(new_prisoner, frame);
4651 /* this is the signal handler that gets called if GtkList
4652 * emits the "selection_changed" signal
4655 sigh_print_selection (GtkWidget *gtklist,
4660 /* fetch the doubly linked list of selected items
4661 * of the GtkList, remember to treat this as read-only!
4663 dlist=GTK_LIST(gtklist)->selection;
4665 /* if there are no selected items there is nothing more
4666 * to do than just telling the user so
4669 g_print("Selection cleared\n");
4672 /* ok, we got a selection and so we print it
4674 g_print("The selection is a ");
4676 /* get the list item from the doubly linked list
4677 * and then query the data associated with list_item_data_key
4678 * we then just print it
4681 GtkObject *list_item;
4682 gchar *item_data_string;
4684 list_item=GTK_OBJECT(dlist->data);
4685 item_data_string=gtk_object_get_data(list_item,
4686 list_item_data_key);
4687 g_print("%s ", item_data_string);
4695 <!-- ----------------------------------------------------------------- -->
4696 <sect1> List Item Widget
4698 The GtkListItem widget is designed to act as a container holding up
4699 to one child, providing functions for selection/deselection just like
4700 the GtkList widget requires them for its children.
4702 A GtkListItem has its own window to receive events and has its own
4703 background color which is usualy white.
4705 As it is directly derived from a
4706 GtkItem it can be treated as such by using the GTK_ITEM(ListItem)
4707 macro, see the GtkItem widget for more on this.
4708 Usualy a GtkListItem just holds a label to identify e.g. a filename
4709 within a GtkList -- therefore the convenient function
4710 gtk_list_item_new_with_label() is provided. The same effect can be
4711 achieved by creating a GtkLabel on its own, setting its alignment
4712 to xalign=0 and yalign=0.5 with a subsequent container addition
4715 As one is not forced to add a GtkLabel to a GtkListItem, you could
4716 also add a GtkVBox or a GtkArrow etc. to the GtkListItem.
4718 <!-- ----------------------------------------------------------------- -->
4721 A GtkListItem does not create new signals on its own, but inherits
4722 the signals of a GtkItem. *Note GtkItem::, for more info.
4724 <!-- ----------------------------------------------------------------- -->
4729 guint gtk_list_item_get_type (void)
4732 Returns the `GtkListItem' type identifier.
4735 GtkWidget* gtk_list_item_new (void)
4738 Create a new `GtkListItem' object. The new widget is
4739 returned as a pointer to a `GtkWidget' object.
4740 `NULL' is returned on failure.
4743 GtkWidget* gtk_list_item_new_with_label (gchar *LABEL)
4746 Create a new `GtkListItem' object, having a single GtkLabel as
4747 the sole child. The new widget is returned as a pointer to a
4749 `NULL' is returned on failure.
4752 void gtk_list_item_select (GtkListItem *LIST_ITEM)
4755 This function is basicaly a wrapper around a call to
4756 gtk_item_select (GTK_ITEM (list_item)) which will emit the
4758 *Note GtkItem::, for more info.
4761 void gtk_list_item_deselect (GtkListItem *LIST_ITEM)
4764 This function is basicaly a wrapper around a call to
4765 gtk_item_deselect (GTK_ITEM (list_item)) which will emit the
4767 *Note GtkItem::, for more info.
4770 GtkListItem* GTK_LIST_ITEM (gpointer OBJ)
4773 Cast a generic pointer to `GtkListItem*'. *Note Standard Macros::,
4777 GtkListItemClass* GTK_LIST_ITEM_CLASS (gpointer CLASS)
4780 Cast a generic pointer to `GtkListItemClass*'. *Note Standard
4781 Macros::, for more info.
4784 gint GTK_IS_LIST_ITEM (gpointer OBJ)
4787 Determine if a generic pointer refers to a `GtkListItem' object.
4788 *Note Standard Macros::, for more info.
4790 <!-- ----------------------------------------------------------------- -->
4793 Please see the GtkList example on this, which covers the usage of a
4794 GtkListItem as well.
4796 <!-- ***************************************************************** -->
4798 <!-- ***************************************************************** -->
4801 There are two ways to create menus, there's the easy way, and there's the
4802 hard way. Both have their uses, but you can usually use the menufactory
4803 (the easy way). The "hard" way is to create all the menus using the calls
4804 directly. The easy way is to use the gtk_menu_factory calls. This is
4805 much simpler, but there are advantages and disadvantages to each approach.
4807 The menufactory is much easier to use, and to add new menus to, although
4808 writing a few wrapper functions to create menus using the manual method
4809 could go a long way towards usability. With the menufactory, it is not
4810 possible to add images or the character '/' to the menus.
4812 <!-- ----------------------------------------------------------------- -->
4813 <sect1>Manual Menu Creation
4815 In the true tradition of teaching, we'll show you the hard
4816 way first. <tt>:)</>
4818 There are three widgets that go into making a menubar and submenus:
4820 <item>a menu item, which is what the user wants to select, e.g. 'Save'
4821 <item>a menu, which acts as a container for the menu items, and
4822 <item>a menubar, which is a container for each of the individual menus,
4825 This is slightly complicated by the fact that menu item widgets are used for two different things. They are
4826 both the widets that are packed into the menu, and the widget that is packed into the menubar, which,
4827 when selected, activiates the menu.
4829 Let's look at the functions that are used to create menus and menubars.
4830 This first function is used to create a new menubar.
4833 GtkWidget *gtk_menu_bar_new(void);
4836 This rather self explanatory function creates a new menubar. You use
4837 gtk_container_add to pack this into a window, or the box_pack functions to
4838 pack it into a box - the same as buttons.
4841 GtkWidget *gtk_menu_new();
4844 This function returns a pointer to a new menu, it is never actually shown
4845 (with gtk_widget_show), it is just a container for the menu items. Hopefully this will
4846 become more clear when you look at the example below.
4848 The next two calls are used to create menu items that are packed into
4849 the menu (and menubar).
4852 GtkWidget *gtk_menu_item_new();
4858 GtkWidget *gtk_menu_item_new_with_label(const char *label);
4861 These calls are used to create the menu items that are to be displayed.
4862 Remember to differentiate between a "menu" as created with gtk_menu_new
4863 and a "menu item" as created by the gtk_menu_item_new functions. The
4864 menu item will be an actual button with an associated action,
4865 whereas a menu will be a container holding menu items.
4867 The gtk_menu_new_with_label and gtk_menu_new functions are just as you'd expect after
4868 reading about the buttons. One creates a new menu item with a label
4869 already packed into it, and the other just creates a blank menu item.
4871 Once you've created a menu item you have to put it into a menu. This is done using the function
4872 gtk_menu_append. In order to capture when the item is selected by the user, we need to connect
4873 to the <tt/activate/ signal in the usual way.
4874 So, if we wanted to create a standard <tt/File/ menu, with the options <tt/Open/,
4875 <tt/Save/ and <tt/Quit/ the code would look something like
4878 file_menu = gtk_menu_new(); /* Don't need to show menus */
4880 /* Create the menu items */
4881 open_item = gtk_menu_item_new_with_label("Open");
4882 save_item = gtk_menu_item_new_with_label("Save");
4883 quit_item = gtk_menu_item_new_with_label("Quit");
4885 /* Add them to the menu */
4886 gtk_menu_append( GTK_MENU(file_menu), open_item);
4887 gtk_menu_append( GTK_MENU(file_menu), save_item);
4888 gtk_menu_append( GTK_MENU(file_menu), quit_item);
4890 /* Attach the callback functions to the activate signal */
4891 gtk_signal_connect_object( GTK_OBJECT(open_items), "activate",
4892 GTK_SIGNAL_FUNC(menuitem_response), (gpointer) "file.open");
4893 gtk_signal_connect_object( GTK_OBJECT(save_items), "activate",
4894 GTK_SIGNAL_FUNC(menuitem_response), (gpointer) "file.save");
4896 /* We can attach the Quit menu item to our exit function */
4897 gtk_signal_connect_object( GTK_OBJECT(quit_items), "activate",
4898 GTK_SIGNAL_FUNC(destroy), (gpointer) "file.quit");
4900 /* We do need to show menu items */
4901 gtk_widget_show( open_item );
4902 gtk_widget_show( save_item );
4903 gtk_widget_show( quit_item );
4906 At this point we have our menu. Now we need to create a menubar and a menu item for the <tt/File/ entry,
4907 to which we add our menu. The code looks like this
4910 menu_bar = gtk_menu_bar_new();
4911 gtk_container_add( GTK_CONTAINER(window), menu_bar);
4912 gtk_widget_show( menu_bar );
4914 file_item = gtk_menu_item_new_with_label("File");
4915 gtk_widget_show(file_item);
4918 Now we need to associate the menu with <tt/file_item/. This is done with the function
4921 void gtk_menu_item_set_submenu( GtkMenuItem *menu_item,
4922 GtkWidget *submenu);
4925 So, our example would continue with
4928 gtk_menu_item_set_submenu( GTK_MENU_ITEM(file_item), file_menu);
4931 All that is left to do is to add the menu to the menubar, which is accomplished using the function
4934 void gtk_menu_bar_append( GtkMenuBar *menu_bar, GtkWidget *menu_item);
4937 which in our case looks like this:
4940 gtk_menu_bar_append( menu_bar, file_item );
4943 If we wanted the menu right justified on the menubar, such as help menus often are, we can
4944 use the following function (again on <tt/file_item/ in the current example) before attaching
4947 void gtk_menu_item_right_justify (GtkMenuItem *menu_item);
4950 Here is a summary of the steps needed to create a menu bar with menus attached:
4952 <item> Create a new menu using gtk_menu_new()
4953 <item> Use multiple calls to gtk_menu_item_new() for each item you wish to have on
4954 your menu. And use gtk_menu_append() to put each of these new items on
4956 <item> Create a menu item using gtk_menu_item_new(). This will be the root of
4957 the menu, the text appearing here will be on the menubar itself.
4958 <item> Use gtk_menu_item_set_submenu() to attach the menu to
4959 the root menu item (The one created in the above step).
4960 <item> Create a new menubar using gtk_menu_bar_new. This step only needs
4961 to be done once when creating a series of menus on one menu bar.
4962 <item> Use gtk_menu_bar_append to put the root menu onto the menubar.
4965 Creating a popup menu is nearly the same. The difference is that the
4966 menu is not posted `automatically' by a menubar, but explicitly
4967 by calling the function gtk_menu_popup() from a button-press event, for example.
4970 <item>Create an event handling function. It needs to have the prototype
4972 static gint handler(GtkWidget *widget, GdkEvent *event);
4974 and it will use the event to find out where to pop up the menu.
4975 <item>In the event handler, if event is a mouse button press, treat
4976 <tt>event</tt> as a button event (which it is) and use it as
4977 shown in the sample code to pass information to gtk_menu_popup().
4978 <item>Bind that event handler to a widget with
4980 gtk_signal_connect_object(GTK_OBJECT(widget), "event",
4981 GTK_SIGNAL_FUNC (handler), GTK_OBJECT(menu));
4983 where <tt>widget</tt> is the widget you are binding to, <tt>handler</tt>
4984 is the handling function, and <tt>menu</tt> is a menu created with
4985 gtk_menu_new(). This can be a menu which is also posted by a menu bar,
4986 as shown in the sample code.
4989 <!-- ----------------------------------------------------------------- -->
4990 <sect1>Manual Menu Example
4992 That should about do it. Let's take a look at an example to help clarify.
4997 #include <gtk/gtk.h>
4999 static gint button_press (GtkWidget *, GdkEvent *);
5000 static void menuitem_response (gchar *);
5002 int main (int argc, char *argv[])
5007 GtkWidget *menu_bar;
5008 GtkWidget *root_menu;
5009 GtkWidget *menu_items;
5015 gtk_init (&argc, &argv);
5017 /* create a new window */
5018 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
5019 gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
5020 gtk_window_set_title(GTK_WINDOW (window), "GTK Menu Test");
5021 gtk_signal_connect(GTK_OBJECT (window), "delete_event",
5022 (GtkSignalFunc) gtk_main_quit, NULL);
5024 /* Init the menu-widget, and remember -- never
5025 * gtk_show_widget() the menu widget!!
5026 * This is the menu that holds the menu items, the one that
5027 * will pop up when you click on the "Root Menu" in the app */
5028 menu = gtk_menu_new();
5030 /* Next we make a little loop that makes three menu-entries for "test-menu".
5031 * Notice the call to gtk_menu_append. Here we are adding a list of
5032 * menu items to our menu. Normally, we'd also catch the "clicked"
5033 * signal on each of the menu items and setup a callback for it,
5034 * but it's omitted here to save space. */
5036 for(i = 0; i < 3; i++)
5038 /* Copy the names to the buf. */
5039 sprintf(buf, "Test-undermenu - %d", i);
5041 /* Create a new menu-item with a name... */
5042 menu_items = gtk_menu_item_new_with_label(buf);
5044 /* ...and add it to the menu. */
5045 gtk_menu_append(GTK_MENU (menu), menu_items);
5047 /* Do something interesting when the menuitem is selected */
5048 gtk_signal_connect_object(GTK_OBJECT(menu_items), "activate",
5049 GTK_SIGNAL_FUNC(menuitem_response), (gpointer) g_strdup(buf));
5051 /* Show the widget */
5052 gtk_widget_show(menu_items);
5055 /* This is the root menu, and will be the label
5056 * displayed on the menu bar. There won't be a signal handler attached,
5057 * as it only pops up the rest of the menu when pressed. */
5058 root_menu = gtk_menu_item_new_with_label("Root Menu");
5060 gtk_widget_show(root_menu);
5062 /* Now we specify that we want our newly created "menu" to be the menu
5063 * for the "root menu" */
5064 gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
5066 /* A vbox to put a menu and a button in: */
5067 vbox = gtk_vbox_new(FALSE, 0);
5068 gtk_container_add(GTK_CONTAINER(window), vbox);
5069 gtk_widget_show(vbox);
5071 /* Create a menu-bar to hold the menus and add it to our main window */
5072 menu_bar = gtk_menu_bar_new();
5073 gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
5074 gtk_widget_show(menu_bar);
5076 /* Create a button to which to attach menu as a popup */
5077 button = gtk_button_new_with_label("press me");
5078 gtk_signal_connect_object(GTK_OBJECT(button), "event",
5079 GTK_SIGNAL_FUNC (button_press), GTK_OBJECT(menu));
5080 gtk_box_pack_end(GTK_BOX(vbox), button, TRUE, TRUE, 2);
5081 gtk_widget_show(button);
5083 /* And finally we append the menu-item to the menu-bar -- this is the
5084 * "root" menu-item I have been raving about =) */
5085 gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), root_menu);
5087 /* always display the window as the last step so it all splashes on
5088 * the screen at once. */
5089 gtk_widget_show(window);
5098 /* Respond to a button-press by posting a menu passed in as widget.
5100 * Note that the "widget" argument is the menu being posted, NOT
5101 * the button that was pressed.
5104 static gint button_press (GtkWidget *widget, GdkEvent *event)
5107 if (event->type == GDK_BUTTON_PRESS) {
5108 GdkEventButton *bevent = (GdkEventButton *) event;
5109 gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
5110 bevent->button, bevent->time);
5111 /* Tell calling code that we have handled this event; the buck
5116 /* Tell calling code that we have not handled this event; pass it on. */
5121 /* Print a string when a menu item is selected */
5123 static void menuitem_response (gchar *string)
5125 printf("%s\n", string);
5129 You may also set a menu item to be insensitive and, using an accelerator
5130 table, bind keys to menu functions.
5132 <!-- ----------------------------------------------------------------- -->
5133 <sect1>Using GtkMenuFactory
5135 Now that we've shown you the hard way, here's how you do it using the
5136 gtk_menu_factory calls.
5138 <!-- ----------------------------------------------------------------- -->
5139 <sect1>Menu Factory Example
5141 Here is an example using the GTK menu factory. This is the first file,
5142 menufactory.h. We keep a separate menufactory.c and mfmain.c because of the global variables used
5143 in the menufactory.c file.
5148 #ifndef __MENUFACTORY_H__
5149 #define __MENUFACTORY_H__
5153 #endif /* __cplusplus */
5155 void get_main_menu (GtkWidget **menubar, GtkAcceleratorTable **table);
5156 void menus_create(GtkMenuEntry *entries, int nmenu_entries);
5160 #endif /* __cplusplus */
5162 #endif /* __MENUFACTORY_H__ */
5165 And here is the menufactory.c file.
5170 #include <gtk/gtk.h>
5171 #include <strings.h>
5176 static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path);
5177 static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path);
5178 void menus_init(void);
5179 void menus_create(GtkMenuEntry * entries, int nmenu_entries);
5182 /* this is the GtkMenuEntry structure used to create new menus. The
5183 * first member is the menu definition string. The second, the
5184 * default accelerator key used to access this menu function with
5185 * the keyboard. The third is the callback function to call when
5186 * this menu item is selected (by the accelerator key, or with the
5187 * mouse.) The last member is the data to pass to your callback function.
5190 static GtkMenuEntry menu_items[] =
5192 {"<Main>/File/New", "<control>N", NULL, NULL},
5193 {"<Main>/File/Open", "<control>O", NULL, NULL},
5194 {"<Main>/File/Save", "<control>S", NULL, NULL},
5195 {"<Main>/File/Save as", NULL, NULL, NULL},
5196 {"<Main>/File/<separator>", NULL, NULL, NULL},
5197 {"<Main>/File/Quit", "<control>Q", file_quit_cmd_callback, "OK, I'll quit"},
5198 {"<Main>/Options/Test", NULL, NULL, NULL}
5201 /* calculate the number of menu_item's */
5202 static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
5204 static int initialize = TRUE;
5205 static GtkMenuFactory *factory = NULL;
5206 static GtkMenuFactory *subfactory[1];
5207 static GHashTable *entry_ht = NULL;
5209 void get_main_menu(GtkWidget ** menubar, GtkAcceleratorTable ** table)
5215 *menubar = subfactory[0]->widget;
5217 *table = subfactory[0]->table;
5220 void menus_init(void)
5225 factory = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
5226 subfactory[0] = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
5228 gtk_menu_factory_add_subfactory(factory, subfactory[0], "<Main>");
5229 menus_create(menu_items, nmenu_items);
5233 void menus_create(GtkMenuEntry * entries, int nmenu_entries)
5242 for (i = 0; i < nmenu_entries; i++) {
5243 accelerator = g_hash_table_lookup(entry_ht, entries[i].path);
5245 if (accelerator[0] == '\0')
5246 entries[i].accelerator = NULL;
5248 entries[i].accelerator = accelerator;
5251 gtk_menu_factory_add_entries(factory, entries, nmenu_entries);
5253 for (i = 0; i < nmenu_entries; i++)
5254 if (entries[i].widget) {
5255 gtk_signal_connect(GTK_OBJECT(entries[i].widget), "install_accelerator",
5256 (GtkSignalFunc) menus_install_accel,
5258 gtk_signal_connect(GTK_OBJECT(entries[i].widget), "remove_accelerator",
5259 (GtkSignalFunc) menus_remove_accel,
5264 static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path)
5270 if (modifiers & GDK_CONTROL_MASK)
5271 strcat(accel, "<control>");
5272 if (modifiers & GDK_SHIFT_MASK)
5273 strcat(accel, "<shift>");
5274 if (modifiers & GDK_MOD1_MASK)
5275 strcat(accel, "<alt>");
5282 t1 = g_hash_table_lookup(entry_ht, path);
5285 entry_ht = g_hash_table_new(g_str_hash, g_str_equal);
5287 g_hash_table_insert(entry_ht, path, g_strdup(accel));
5292 static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path)
5297 t = g_hash_table_lookup(entry_ht, path);
5300 g_hash_table_insert(entry_ht, path, g_strdup(""));
5304 void menus_set_sensitive(char *path, int sensitive)
5306 GtkMenuPath *menu_path;
5311 menu_path = gtk_menu_factory_find(factory, path);
5313 gtk_widget_set_sensitive(menu_path->widget, sensitive);
5315 g_warning("Unable to set sensitivity for menu which doesn't exist: %s", path);
5320 And here's the mfmain.h
5325 #ifndef __MFMAIN_H__
5326 #define __MFMAIN_H__
5331 #endif /* __cplusplus */
5333 void file_quit_cmd_callback(GtkWidget *widget, gpointer data);
5337 #endif /* __cplusplus */
5339 #endif /* __MFMAIN_H__ */
5347 #include <gtk/gtk.h>
5350 #include "menufactory.h"
5353 int main(int argc, char *argv[])
5356 GtkWidget *main_vbox;
5359 GtkAcceleratorTable *accel;
5361 gtk_init(&argc, &argv);
5363 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
5364 gtk_signal_connect(GTK_OBJECT(window), "destroy",
5365 GTK_SIGNAL_FUNC(file_quit_cmd_callback),
5367 gtk_window_set_title(GTK_WINDOW(window), "Menu Factory");
5368 gtk_widget_set_usize(GTK_WIDGET(window), 300, 200);
5370 main_vbox = gtk_vbox_new(FALSE, 1);
5371 gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
5372 gtk_container_add(GTK_CONTAINER(window), main_vbox);
5373 gtk_widget_show(main_vbox);
5375 get_main_menu(&menubar, &accel);
5376 gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
5377 gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
5378 gtk_widget_show(menubar);
5380 gtk_widget_show(window);
5386 /* This is just to demonstrate how callbacks work when using the
5387 * menufactory. Often, people put all the callbacks from the menus
5388 * in a separate file, and then have them call the appropriate functions
5389 * from there. Keeps it more organized. */
5390 void file_quit_cmd_callback (GtkWidget *widget, gpointer data)
5392 g_print ("%s\n", (char *) data);
5397 And a makefile so it'll be easier to compile it.
5404 C_FLAGS = -Wall $(PROF) -L/usr/local/include -DDEBUG
5405 L_FLAGS = $(PROF) -L/usr/X11R6/lib -L/usr/local/lib
5406 L_POSTFLAGS = -lgtk -lgdk -lglib -lXext -lX11 -lm
5407 PROGNAME = menufactory
5409 O_FILES = menufactory.o mfmain.o
5411 $(PROGNAME): $(O_FILES)
5413 $(CC) $(L_FLAGS) -o $(PROGNAME) $(O_FILES) $(L_POSTFLAGS)
5416 $(CC) -c $(C_FLAGS) $<
5419 rm -f core *.o $(PROGNAME) nohup.out
5424 For now, there's only this example. An explanation and lots 'o' comments
5427 <!-- ***************************************************************** -->
5429 <!-- ***************************************************************** -->
5431 The Text widget allows multiple lines of text to be displayed and edited. It supports both
5432 multi-colored and multi-font text, allowing them to be mixed in any way we wish. It also has
5433 a wide set of key based text editing commands, which are compatible with Emacs.
5435 The text widget supports full cut-and-paste facilities, including the use of double- and
5436 triple-click to select a word and a whole line, respectively.
5438 <!-- ----------------------------------------------------------------- -->
5439 <sect1>Creating and Configuring a Text box
5441 There is only one function for creating a new Text widget.
5443 GtkWidget* gtk_text_new (GtkAdjustment *hadj,
5444 GtkAdjustment *vadj);
5447 The arguments allow us to give the Text widget pointers to Adjustments that can be used
5448 to track the viewing position of the widget. Passing NULL values to either or both of
5449 these arguments will cause the gtk_text_new function to create it's own.
5452 void gtk_text_set_adjustments (GtkText *text,
5453 GtkAdjustment *hadj,
5454 GtkAdjustment *vadj);
5457 The above function allows the horizontal and vertical adjustments of a Text widget to be
5458 changed at any time.
5460 The text widget will not automatically create it's own scrollbars when the amount of text
5461 to be displayed is too long for the display window. We therefore have to create and add
5462 them to the display layout ourselves.
5465 vscrollbar = gtk_vscrollbar_new (GTK_TEXT(text)->vadj);
5466 gtk_box_pack_start(GTK_BOX(hbox), vscrollbar, FALSE, FALSE, 0);
5467 gtk_widget_show (vscrollbar);
5470 The above code snippet creates a new vertical scrollbar, and attaches it to the vertical
5471 adjustment of the text widget, <tt/text/. It then packs it into a box in the normal way.
5473 There are two main ways in which a Text widget can be used: to allow the user to edit a
5474 body of text, or to allow us to display multiple lines of text to the user. In order for
5475 us to switch between these modes of operation, the text widget has the following function:
5478 void gtk_text_set_editable (GtkText *text,
5482 The <tt/editable/ argument is a TRUE or FALSE value that specifies whether the user is
5483 permitted to edit the contents of the Text widget. When the text widget is editable, it
5484 will display a cursor at the current insertion point.
5486 You are not, however, restricted to just using the text widget in these two modes. You can
5487 toggle the editable state of the text widget at any time, and can insert text at any time.
5489 The text widget is capable of wrapping lines of text that are too long to fit onto a single
5490 line of the display window. It's default behaviour is to break words across line breaks. This
5491 can be changed using the next function:
5494 void gtk_text_set_word_wrap (GtkText *text,
5498 Using this function allows us to specify that the text widget should wrap long lines on word
5499 boundaries. The <tt/word_wrap/ argument is a TRUE or FALSE value.
5501 <!-- ----------------------------------------------------------------- -->
5502 <sect1>Text Manipulation
5504 The current insertion point of a Text widget can be set using
5506 void gtk_text_set_point (GtkText *text,
5509 where <tt/index/ is the position to set the insertion point.
5511 Analogous to this is the function for getting the current insertion point:
5513 guint gtk_text_get_point (GtkText *text);
5516 A function that is useful in combination with the above two functions is
5518 guint gtk_text_get_length (GtkText *text);
5520 which returns the current length of the Text widget. The length is the number of characters
5521 that are within the text block of the widget, including characters such as carriage-return,
5522 which marks the end of lines.
5524 In order to insert text at the current insertion point of a Text widget, the function
5525 gtk_text_insert is used, which also allows us to specify background and foreground colors and a
5529 void gtk_text_insert (GtkText *text,
5537 Passing a value of <tt/NULL/ in as the value for the foreground color, background colour or
5538 font will result in the values set within the widget style to be used. Using a value of <tt/-1/ for
5539 the length parameter will result in the whole of the text string given being inserted.
5541 The text widget is one of the few within GTK that redraws itself dynamically, outside of the gtk_main
5542 function. This means that all changes to the contents of the text widget take effect immediately. This
5543 may be undesirable when performing multiple changes to the text widget. In order to allow us to perform
5544 multiple updates to the text widget without it continuously redrawing, we can freeze the widget, which
5545 temporarily stops it from automatically redrawing itself every time it is changed. We can then thaw the
5546 widget after our updates are complete.
5548 The following two functions perform this freeze and thaw action:
5551 void gtk_text_freeze (GtkText *text);
5552 void gtk_text_thaw (GtkText *text);
5555 Text is deleted from the text widget relative to the current insertion point by the following
5559 gint gtk_text_backward_delete (GtkText *text,
5561 gint gtk_text_forward_delete (GtkText *text,
5565 If you want to retrieve the contents of the text widget, then the macro
5566 <tt/GTK_TEXT_INDEX(t, index)/ allows you to retrieve the character at position
5567 <tt/index/ within the text widget <tt/t/.
5569 To retrieve larger blocks of text, we can use the function
5572 gchar *gtk_editable_get_chars (GtkEditable *editable,
5577 This is a function of the parent class of the text widget. A value of -1 as
5578 <tt/end_pos/ signifies the end of the text. The index of the text starts at 0.
5580 The function allocates a new chunk of memory for the text block, so don't forget
5581 to free it with a call to g_free when you have finished with it.
5583 <!-- ----------------------------------------------------------------- -->
5584 <sect1>Keyboard Shortcuts
5586 The text widget has a number of pre-installed keyboard shotcuts for common
5587 editing, motion and selection functions. These are accessed using Control and Alt
5590 In addition to these, holding down the Control key whilst using cursor key movement
5591 will move the cursor by words rather than characters. Holding down Shift whilst using
5592 cursor movement will extend the selection.
5594 <sect2>Motion Shotcuts
5597 <item> Ctrl-A Beginning of line
5598 <item> Ctrl-E End of line
5599 <item> Ctrl-N Next Line
5600 <item> Ctrl-P Previous Line
5601 <item> Ctrl-B Backward one character
5602 <item> Ctrl-F Forward one character
5603 <item> Alt-B Backward one word
5604 <item> Alt-F Forward one word
5607 <sect2>Editing Shortcuts
5610 <item> Ctrl-H Delete Backward Character (Backspace)
5611 <item> Ctrl-D Delete Forward Character (Delete)
5612 <item> Ctrl-W Delete Backward Word
5613 <item> Alt-D Delete Forward Word
5614 <item> Ctrl-K Delete to end of line
5615 <item> Ctrl-U Delete line
5618 <sect2>Selection Shortcuts
5621 <item> Ctrl-X Cut to clipboard
5622 <item> Ctrl-C Copy to clipboard
5623 <item> Ctrl-V Paste from clipboard
5626 <!-- ***************************************************************** -->
5627 <sect> Undocumented Widgets
5628 <!-- ***************************************************************** -->
5631 These all require authors! :) Please consider contributing to our tutorial.
5633 If you must use one of these widgets that are undocumented, I strongly
5634 suggest you take a look at their respective header files in the GTK distro.
5635 GTK's function names are very descriptive. Once you have an understanding
5636 of how things work, it's not easy to figure out how to use a widget simply
5637 by looking at it's function declarations. This, along with a few examples
5638 from others' code, and it should be no problem.
5640 When you do come to understand all the functions of a new undocumented
5641 widget, please consider writing a tutorial on it so others may benifit from
5644 <!-- ----------------------------------------------------------------- -->
5645 <sect1> Range Controls
5647 <!-- ----------------------------------------------------------------- -->
5651 (This may need to be rewritten to follow the style of the rest of the tutorial)
5655 Previews serve a number of purposes in GIMP/GTK. The most important one is
5656 this. High quality images may take up to tens of megabytes of memory - easy!
5657 Any operation on an image that big is bound to take a long time. If it takes
5658 you 5-10 trial-and-errors (i.e. 10-20 steps, since you have to revert after
5659 you make an error) to choose the desired modification, it make take you
5660 literally hours to make the right one - if you don't run out of memory
5661 first. People who have spent hours in color darkrooms know the feeling.
5662 Previews to the rescue!
5664 But the annoyance of the delay is not the only issue. Oftentimes it is
5665 helpful to compare the Before and After versions side-by-side or at least
5666 back-to-back. If you're working with big images and 10 second delays,
5667 obtaining the Before and After impressions is, to say the least, difficult.
5668 For 30M images (4"x6", 600dpi, 24 bit) the side-by-side comparison is right
5669 out for most people, while back-to-back is more like back-to-1001, 1002,
5670 ..., 1010-back! Previews to the rescue!
5672 But there's more. Previews allow for side-by-side pre-previews. In other
5673 words, you write a plug-in (e.g. the filterpack simulation) which would have
5674 a number of here's-what-it-would-look-like-if-you-were-to-do-this previews.
5675 An approach like this acts as a sort of a preview palette and is very
5676 effective fow subtle changes. Let's go previews!
5678 There's more. For certain plug-ins real-time image-specific human
5679 intervention maybe necessary. In the SuperNova plug-in, for example, the
5680 user is asked to enter the coordinates of the center of the future
5681 supernova. The easiest way to do this, really, is to present the user with a
5682 preview and ask him to intereactively select the spot. Let's go previews!
5684 Finally, a couple of misc uses. One can use previews even when not working
5685 with big images. For example, they are useful when rendering compicated
5686 patterns. (Just check out the venerable Diffraction plug-in + many other
5687 ones!) As another example, take a look at the colormap rotation plug-in
5688 (work in progress). You can also use previews for little logo's inside you
5689 plug-ins and even for an image of yourself, The Author. Let's go previews!
5691 When Not to Use Previews
5693 Don't use previews for graphs, drawing etc. GDK is much faster for that. Use
5694 previews only for rendered images!
5698 You can stick a preview into just about anything. In a vbox, an hbox, a
5699 table, a button, etc. But they look their best in tight frames around them.
5700 Previews by themselves do not have borders and look flat without them. (Of
5701 course, if the flat look is what you want...) Tight frames provide the
5706 Previews in many ways are like any other widgets in GTK (whatever that
5707 means) except they possess an addtional feature: they need to be filled with
5708 some sort of an image! First, we will deal exclusively with the GTK aspect
5709 of previews and then we'll discuss how to fill them.
5715 /* Create a preview widget,
5716 set its size, an show it */
5718 preview=gtk_preview_new(GTK_PREVIEW_COLOR)
5720 GTK_PREVIEW_GRAYSCALE);*/
5721 gtk_preview_size (GTK_PREVIEW (preview), WIDTH, HEIGHT);
5722 gtk_widget_show(preview);
5723 my_preview_rendering_function(preview);
5725 Oh yeah, like I said, previews look good inside frames, so how about:
5727 GtkWidget *create_a_preview(int Width,
5734 frame = gtk_frame_new(NULL);
5735 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5736 gtk_container_border_width (GTK_CONTAINER(frame),0);
5737 gtk_widget_show(frame);
5739 preview=gtk_preview_new (Colorfulness?GTK_PREVIEW_COLOR
5740 :GTK_PREVIEW_GRAYSCALE);
5741 gtk_preview_size (GTK_PREVIEW (preview), Width, Height);
5742 gtk_container_add(GTK_CONTAINER(frame),preview);
5743 gtk_widget_show(preview);
5745 my_preview_rendering_function(preview);
5749 That's my basic preview. This routine returns the "parent" frame so you can
5750 place it somewhere else in your interface. Of course, you can pass the
5751 parent frame to this routine as a parameter. In many situations, however,
5752 the contents of the preview are changed continually by your application. In
5753 this case you may want to pass a pointer to the preview to a
5754 "create_a_preview()" and thus have control of it later.
5756 One more important note that may one day save you a lot of time. Sometimes
5757 it is desirable to label you preview. For example, you may label the preview
5758 containing the original image as "Original" and the one containing the
5759 modified image as "Less Original". It might occure to you to pack the
5760 preview along with the appropriate label into a vbox. The unexpected caveat
5761 is that if the label is wider than the preview (which may happen for a
5762 variety of reasons unforseeable to you, from the dynamic decision on the
5763 size of the preview to the size of the font) the frame expands and no longer
5764 fits tightly over the preview. The same problem can probably arise in other
5769 The solution is to place the preview and the label into a 2x1 table and by
5770 attaching them with the following paramters (this is one possible variations
5771 of course. The key is no GTK_FILL in the second attachment):
5773 gtk_table_attach(GTK_TABLE(table),label,0,1,0,1,
5775 GTK_EXPAND|GTK_FILL,
5777 gtk_table_attach(GTK_TABLE(table),frame,0,1,1,2,
5783 And here's the result:
5789 Making a preview clickable is achieved most easily by placing it in a
5790 button. It also adds a nice border around the preview and you may not even
5791 need to place it in a frame. See the Filter Pack Simulation plug-in for an
5794 This is pretty much it as far as GTK is concerned.
5796 Filling In a Preview
5798 In order to familiarize ourselves with the basics of filling in previews,
5799 let's create the following pattern (contrived by trial and error):
5804 my_preview_rendering_function(GtkWidget *preview)
5807 #define HALF (SIZE/2)
5809 guchar *row=(guchar *) malloc(3*SIZE); /* 3 bits per dot */
5810 gint i, j; /* Coordinates */
5811 double r, alpha, x, y;
5813 if (preview==NULL) return; /* I usually add this when I want */
5814 /* to avoid silly crashes. You */
5815 /* should probably make sure that */
5816 /* everything has been nicely */
5818 for (j=0; j < ABS(cos(2*alpha)) ) { /* Are we inside the shape? */
5819 /* glib.h contains ABS(x). */
5820 row[i*3+0] = sqrt(1-r)*255; /* Define Red */
5821 row[i*3+1] = 128; /* Define Green */
5822 row[i*3+2] = 224; /* Define Blue */
5823 } /* "+0" is for alignment! */
5826 row[i*3+1] = ABS(sin((float)i/SIZE*2*PI))*255;
5827 row[i*3+2] = ABS(sin((float)j/SIZE*2*PI))*255;
5830 gtk_preview_draw_row( GTK_PREVIEW(preview),row,0,j,SIZE);
5831 /* Insert "row" into "preview" starting at the point with */
5832 /* coordinates (0,j) first column, j_th row extending SIZE */
5833 /* pixels to the right */
5836 free(row); /* save some space */
5837 gtk_widget_draw(preview,NULL); /* what does this do? */
5838 gdk_flush(); /* or this? */
5841 Non-GIMP users can have probably seen enough to do a lot of things already.
5842 For the GIMP users I have a few pointers to add.
5846 It is probably wize to keep a reduced version of the image around with just
5847 enough pixels to fill the preview. This is done by selecting every n'th
5848 pixel where n is the ratio of the size of the image to the size of the
5849 preview. All further operations (including filling in the previews) are then
5850 performed on the reduced number of pixels only. The following is my
5851 implementation of reducing the image. (Keep in mind that I've had only basic
5854 (UNTESTED CODE ALERT!!!)
5866 SELCTION_IN_CONTEXT,
5870 ReducedImage *Reduce_The_Image(GDrawable *drawable,
5875 /* This function reduced the image down to the the selected preview size */
5876 /* The preview size is determine by LongerSize, i.e. the greater of the */
5877 /* two dimentions. Works for RGB images only! */
5878 gint RH, RW; /* Reduced height and reduced width */
5879 gint width, height; /* Width and Height of the area being reduced */
5880 gint bytes=drawable->bpp;
5881 ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage));
5883 guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B;
5884 gint i, j, whichcol, whichrow, x1, x2, y1, y2;
5885 GPixelRgn srcPR, srcMask;
5886 gint NoSelectionMade=TRUE; /* Assume that we're dealing with the entire */
5889 gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
5892 /* If there's a SELECTION, we got its bounds!)
5894 if (width != drawable->width && height != drawable->height)
5895 NoSelectionMade=FALSE;
5896 /* Become aware of whether the user has made an active selection */
5897 /* This will become important later, when creating a reduced mask. */
5899 /* If we want to preview the entire image, overrule the above! */
5900 /* Of course, if no selection has been made, this does nothing! */
5901 if (Selection==ENTIRE_IMAGE) {
5905 y2=drawable->height;
5908 /* If we want to preview a selection with some surronding area we */
5909 /* have to expand it a little bit. Consider it a bit of a riddle. */
5910 if (Selection==SELECTION_IN_CONTEXT) {
5911 x1=MAX(0, x1-width/2.0);
5912 x2=MIN(drawable->width, x2+width/2.0);
5913 y1=MAX(0, y1-height/2.0);
5914 y2=MIN(drawable->height, y2+height/2.0);
5917 /* How we can determine the width and the height of the area being */
5922 /* The lines below determine which dimension is to be the longer */
5923 /* side. The idea borrowed from the supernova plug-in. I suspect I */
5924 /* could've thought of it myself, but the truth must be told. */
5925 /* Plagiarism stinks! */
5928 RH=(float) height * (float) LongerSize/ (float) width;
5932 RW=(float)width * (float) LongerSize/ (float) height;
5935 /* The intire image is stretched into a string! */
5936 tempRGB = (guchar *) malloc(RW*RH*bytes);
5937 tempmask = (guchar *) malloc(RW*RH);
5939 gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, width, height, FALSE, FALSE);
5940 gimp_pixel_rgn_init (&srcMask, mask, x1, y1, width, height, FALSE, FALSE);
5942 /* Grab enough to save a row of image and a row of mask. */
5943 src_row = (guchar *) malloc (width*bytes);
5944 src_mask_row = (guchar *) malloc (width);
5946 for (i=0; i < RH; i++) {
5947 whichrow=(float)i*(float)height/(float)RH;
5948 gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y1+whichrow, width);
5949 gimp_pixel_rgn_get_row (&srcMask, src_mask_row, x1, y1+whichrow, width);
5951 for (j=0; j < RW; j++) {
5952 whichcol=(float)j*(float)width/(float)RW;
5954 /* No selection made = each point is completely selected! */
5955 if (NoSelectionMade)
5956 tempmask[i*RW+j]=255;
5958 tempmask[i*RW+j]=src_mask_row[whichcol];
5960 /* Add the row to the one long string which now contains the image! */
5961 tempRGB[i*RW*bytes+j*bytes+0]=src_row[whichcol*bytes+0];
5962 tempRGB[i*RW*bytes+j*bytes+1]=src_row[whichcol*bytes+1];
5963 tempRGB[i*RW*bytes+j*bytes+2]=src_row[whichcol*bytes+2];
5965 /* Hold on to the alpha as well */
5967 tempRGB[i*RW*bytes+j*bytes+3]=src_row[whichcol*bytes+3];
5974 temp->mask=tempmask;
5978 The following is a preview function which used the same ReducedImage type!
5979 Note that it uses fakes transparancy (if one is present by means of
5980 fake_transparancy which is defined as follows:
5982 gint fake_transparency(gint i, gint j)
5984 if ( ((i%20)- 10) * ((j%20)- 10)>0 )
5990 Now here's the preview function:
5993 my_preview_render_function(GtkWidget *preview,
5997 gint Inten, bytes=drawable->bpp;
6000 gint RW=reduced->width;
6001 gint RH=reduced->height;
6002 guchar *row=malloc(bytes*RW);;
6005 for (i=0; i < RH; i++) {
6006 for (j=0; j < RW; j++) {
6008 row[j*3+0] = reduced->rgb[i*RW*bytes + j*bytes + 0];
6009 row[j*3+1] = reduced->rgb[i*RW*bytes + j*bytes + 1];
6010 row[j*3+2] = reduced->rgb[i*RW*bytes + j*bytes + 2];
6013 for (k=0; k<3; k++) {
6014 float transp=reduced->rgb[i*RW*bytes+j*bytes+3]/255.0;
6015 row[3*j+k]=transp*a[3*j+k]+(1-transp)*fake_transparency(i,j);
6018 gtk_preview_draw_row( GTK_PREVIEW(preview),row,0,i,RW);
6022 gtk_widget_draw(preview,NULL);
6028 guint gtk_preview_get_type (void);
6030 void gtk_preview_uninit (void);
6032 GtkWidget* gtk_preview_new (GtkPreviewType type);
6033 /* Described above */
6034 void gtk_preview_size (GtkPreview *preview,
6037 /* Allows you to resize an existing preview. */
6038 /* Apparantly there's a bug in GTK which makes */
6039 /* this process messy. A way to clean up a mess */
6040 /* is to manually resize the window containing */
6041 /* the preview after resizing the preview. */
6043 void gtk_preview_put (GtkPreview *preview,
6054 void gtk_preview_put_row (GtkPreview *preview,
6062 void gtk_preview_draw_row (GtkPreview *preview,
6067 /* Described in the text */
6069 void gtk_preview_set_expand (GtkPreview *preview,
6073 /* No clue for any of the below but */
6074 /* should be standard for most widgets */
6075 void gtk_preview_set_gamma (double gamma);
6076 void gtk_preview_set_color_cube (guint nred_shades,
6077 guint ngreen_shades,
6079 guint ngray_shades);
6080 void gtk_preview_set_install_cmap (gint install_cmap);
6081 void gtk_preview_set_reserved (gint nreserved);
6082 GdkVisual* gtk_preview_get_visual (void);
6083 GdkColormap* gtk_preview_get_cmap (void);
6084 GtkPreviewInfo* gtk_preview_get_info (void);
6090 <!-- ----------------------------------------------------------------- -->
6094 <!-- ***************************************************************** -->
6095 <sect>The EventBox Widget<label id="sec_The_EventBox_Widget">
6096 <!-- ***************************************************************** -->
6099 Some gtk widgets don't have associated X windows, so they just draw on
6100 thier parents. Because of this, they cannot recieve events
6101 and if they are incorrectly sized, they don't clip so you can get
6102 messy overwritting etc. If you require more from these widgets, the
6103 EventBox is for you.
6105 At first glance, the EventBox widget might appear to be totally
6106 useless. It draws nothing on the screen and responds to no
6107 events. However, it does serve a function - it provides an X window for
6108 its child widget. This is important as many GTK widgets do not
6109 have an associated X window. Not having an X window saves memory and
6110 improves performance, but also has some drawbacks. A widget without an
6111 X window cannot receive events, and does not perform any clipping on
6112 it's contents. Although the name ``EventBox'' emphasizes the
6113 event-handling function, the widget also can be used for clipping.
6114 (And more ... see the example below.)
6117 To create a new EventBox widget, use:
6120 GtkWidget* gtk_event_box_new (void);
6124 A child widget can then be added to this EventBox:
6127 gtk_container_add (GTK_CONTAINER(event_box), widget);
6131 The following example demonstrates both uses of an EventBox - a label
6132 is created that clipped to a small box, and set up so that a
6133 mouse-click on the label causes the program to exit.
6138 #include <gtk/gtk.h>
6141 main (int argc, char *argv[])
6144 GtkWidget *event_box;
6147 gtk_init (&argc, &argv);
6149 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6151 gtk_window_set_title (GTK_WINDOW (window), "Event Box");
6153 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6154 GTK_SIGNAL_FUNC (gtk_exit), NULL);
6156 gtk_container_border_width (GTK_CONTAINER (window), 10);
6158 /* Create an EventBox and add it to our toplevel window */
6160 event_box = gtk_event_box_new ();
6161 gtk_container_add (GTK_CONTAINER(window), event_box);
6162 gtk_widget_show (event_box);
6164 /* Create a long label */
6166 label = gtk_label_new ("Click here to quit, quit, quit, quit, quit");
6167 gtk_container_add (GTK_CONTAINER (event_box), label);
6168 gtk_widget_show (label);
6170 /* Clip it short. */
6171 gtk_widget_set_usize (label, 110, 20);
6173 /* And bind an action to it */
6174 gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
6175 gtk_signal_connect (GTK_OBJECT(event_box), "button_press_event",
6176 GTK_SIGNAL_FUNC (gtk_exit), NULL);
6178 /* Yet one more thing you need an X window for ... */
6180 gtk_widget_realize (event_box);
6181 gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));
6183 gtk_widget_show (window);
6191 <!-- ***************************************************************** -->
6192 <sect>Setting Widget Attributes<label id="sec_setting_widget_attributes">
6193 <!-- ***************************************************************** -->
6196 This describes the functions used to operate on widgets. These can be used
6197 to set style, padding, size etc.
6199 (Maybe I should make a whole section on accelerators.)
6202 void gtk_widget_install_accelerator (GtkWidget *widget,
6203 GtkAcceleratorTable *table,
6208 void gtk_widget_remove_accelerator (GtkWidget *widget,
6209 GtkAcceleratorTable *table,
6210 gchar *signal_name);
6212 void gtk_widget_activate (GtkWidget *widget);
6214 void gtk_widget_set_name (GtkWidget *widget,
6216 gchar* gtk_widget_get_name (GtkWidget *widget);
6218 void gtk_widget_set_sensitive (GtkWidget *widget,
6221 void gtk_widget_set_style (GtkWidget *widget,
6224 GtkStyle* gtk_widget_get_style (GtkWidget *widget);
6226 GtkStyle* gtk_widget_get_default_style (void);
6228 void gtk_widget_set_uposition (GtkWidget *widget,
6231 void gtk_widget_set_usize (GtkWidget *widget,
6235 void gtk_widget_grab_focus (GtkWidget *widget);
6237 void gtk_widget_show (GtkWidget *widget);
6239 void gtk_widget_hide (GtkWidget *widget);
6242 <!-- ***************************************************************** -->
6243 <sect>Timeouts, IO and Idle Functions<label id="sec_timeouts">
6244 <!-- ***************************************************************** -->
6246 <!-- ----------------------------------------------------------------- -->
6249 You may be wondering how you make GTK do useful work when in gtk_main.
6250 Well, you have several options. Using the following functions you can
6251 create a timeout function that will be called every "interval" milliseconds.
6254 gint gtk_timeout_add (guint32 interval,
6255 GtkFunction function,
6259 The first argument is the number of milliseconds
6260 between calls to your function. The second argument is the function
6261 you wish to have called, and
6262 the third, the data passed to this callback function. The return value is
6263 an integer "tag" which may be used to stop the timeout by calling:
6266 void gtk_timeout_remove (gint tag);
6269 You may also stop the timeout function by returning zero or FALSE from
6270 your callback function. Obviously this means if you want your function to
6271 continue to be called, it should return a non-zero value, ie TRUE.
6273 The declaration of your callback should look something like this:
6276 gint timeout_callback (gpointer data);
6279 <!-- ----------------------------------------------------------------- -->
6280 <sect1>Monitoring IO
6282 Another nifty feature of GTK, is the ability to have it check for data on a
6283 file descriptor for you (as returned by open(2) or socket(2)). This is
6284 especially useful for networking applications. The function:
6287 gint gdk_input_add (gint source,
6288 GdkInputCondition condition,
6289 GdkInputFunction function,
6293 Where the first argument is the file descriptor you wish to have watched,
6294 and the second specifies what you want GDK to look for. This may be one of:
6296 GDK_INPUT_READ - Call your function when there is data ready for reading on
6297 your file descriptor.
6299 GDK_INPUT_WRITE - Call your function when the file descriptor is ready for
6302 As I'm sure you've figured out already, the third argument is the function
6303 you wish to have called when the above conditions are satisfied, and the
6304 fourth is the data to pass to this function.
6306 The return value is a tag that may be used to stop GDK from monitoring this
6307 file descriptor using the following function.
6310 void gdk_input_remove (gint tag);
6313 The callback function should be declared:
6316 void input_callback (gpointer data, gint source,
6317 GdkInputCondition condition);
6321 <!-- ----------------------------------------------------------------- -->
6322 <sect1>Idle Functions
6324 What if you have a function you want called when nothing else is
6328 gint gtk_idle_add (GtkFunction function,
6332 This causes GTK to call the specified function whenever nothing else is
6336 void gtk_idle_remove (gint tag);
6339 I won't explain the meaning of the arguments as they follow very much like
6340 the ones above. The function pointed to by the first argument to
6341 gtk_idle_add will be called whenever the opportunity arises. As with the
6342 others, returning FALSE will stop the idle function from being called.
6344 <!-- ***************************************************************** -->
6345 <sect>Managing Selections
6346 <!-- ***************************************************************** -->
6348 <!-- ----------------------------------------------------------------- -->
6353 One type of interprocess communication supported by GTK is
6354 <em>selections</em>. A selection identifies a chunk of data, for
6355 instance, a portion of text, selected by the user in some fashion, for
6356 instance, by dragging with the mouse. Only one application on a
6357 display, (he <em>owner</em>_ can own a particular selection at one
6358 time, so when a selection is claimed by one application, the previous
6359 owner must indicate to the user that selection has been
6360 relinquished. Other applications can request the contents of a
6361 selection in different forms, called <em>targets</em>. There can be
6362 any number of selections, but most X applications only handle one, the
6363 <em>primary selection</em>.
6366 In most cases, it isn't necessary for a GTK application to deal with
6367 selections itself. The standard widgets, such as the Entry widget,
6368 already have the capability to claim the selection when appropriate
6369 (e.g., when the user drags over text), and to retrieve the contents of
6370 the selection owned by another widget, or another application (e.g.,
6371 when the user clicks the second mouse button). However, there may be
6372 cases in which you want to give other widgets the ability to supply
6373 the selection, or you wish to retrieve targets not supported by
6377 A fundamental concept needed to understand selection handling is that
6378 of the <em>atom</em>. An atom is an integer that uniquely identifies a
6379 string (on a certain display). Certain atoms are predefined by the X
6380 server, and in some cases there are constants in in <tt>gtk.h</tt>
6381 corresponding to these atoms. For instance the constant
6382 <tt>GDK_PRIMARY_SELECTION</tt> corresponds to the string "PRIMARY".
6383 In other cases, you should use the functions
6384 <tt>gdk_atom_intern()</tt>, to get the atom corresponding to a string,
6385 and <tt>gdk_atom_name()</tt>, to get the name of an atom. Both
6386 selections and targets are identifed by atoms.
6388 <!-- ----------------------------------------------------------------- -->
6389 <sect1> Retrieving the selection
6393 Retrieving the selection is an asynchronous process. To start the
6397 gint gtk_selection_convert (GtkWidget *widget,
6403 This <em>converts</em> the selection into the form specified by
6404 <tt/target/. If it all possible, the time field should be the time
6405 from the event that triggered the selection. This helps make sure that
6406 events occur in the order that the user requested them.
6407 However, if it is not available (for instance, if the conversion was
6408 triggered by a "clicked" signal), then you can use the constant
6409 <tt>GDK_CURRENT_TIME</tt>.
6412 When the selection owner responds to the request, a
6413 "selection_received" signal is sent to your application. The handler
6414 for this signal receives a pointer to a <tt>GtkSelectionData</tt>
6415 structure, which is defined as:
6418 struct _GtkSelectionData
6429 <tt>selection</tt> and <tt>target</tt> are the values you gave in your
6430 <tt>gtk_selection_convert()</tt> call. <tt>type</tt> is an atom that
6431 identifies the type of data returned by the selection owner. Some
6432 possible values are "STRING", a string of latin-1 characters, "ATOM",
6433 a series of atoms, "INTEGER", an integer, etc. Most targets can only
6434 return one type. <tt/format/ gives the length of the units (for
6435 instance characters) in bits. Usually, you don't care about this when
6436 receiving data. <tt>data</tt> is a pointer to the returned data, and
6437 <tt>length</tt> gives the length of the returned data, in bytes. If
6438 <tt>length</tt> is negative, then an error occurred and the selection
6439 could not be retrieved. This might happen if no application owned the
6440 selection, or if you requested a target that the application didn't
6441 support. The buffer is actually guaranteed to be one byte longer than
6442 <tt>length</tt>; the extra byte will always be zero, so it isn't
6443 necessary to make a copy of strings just to null terminate them.
6446 In the following example, we retrieve the special target "TARGETS",
6447 which is a list of all targets into which the selection can be
6453 #include <gtk/gtk.h>
6455 void selection_received (GtkWidget *widget,
6456 GtkSelectionData *selection_data,
6459 /* Signal handler invoked when user clicks on the "Get Targets" button */
6461 get_targets (GtkWidget *widget, gpointer data)
6463 static GdkAtom targets_atom = GDK_NONE;
6465 /* Get the atom corresonding to the string "TARGETS" */
6466 if (targets_atom == GDK_NONE)
6467 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
6469 /* And request the "TARGETS" target for the primary selection */
6470 gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, targets_atom,
6474 /* Signal handler called when the selections owner returns the data */
6476 selection_received (GtkWidget *widget, GtkSelectionData *selection_data,
6483 /* **** IMPORTANT **** Check to see if retrieval succeeded */
6484 if (selection_data->length < 0)
6486 g_print ("Selection retrieval failed\n");
6489 /* Make sure we got the data in the expected form */
6490 if (selection_data->type != GDK_SELECTION_TYPE_ATOM)
6492 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
6496 /* Print out the atoms we received */
6497 atoms = (GdkAtom *)selection_data->data;
6500 for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
6503 name = gdk_atom_name (atoms[i]);
6505 g_print ("%s\n",name);
6507 g_print ("(bad atom)\n");
6514 main (int argc, char *argv[])
6519 gtk_init (&argc, &argv);
6521 /* Create the toplevel window */
6523 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6524 gtk_window_set_title (GTK_WINDOW (window), "Event Box");
6525 gtk_container_border_width (GTK_CONTAINER (window), 10);
6527 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6528 GTK_SIGNAL_FUNC (gtk_exit), NULL);
6530 /* Create a button the user can click to get targets */
6532 button = gtk_button_new_with_label ("Get Targets");
6533 gtk_container_add (GTK_CONTAINER (window), button);
6535 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6536 GTK_SIGNAL_FUNC (get_targets), NULL);
6537 gtk_signal_connect (GTK_OBJECT(button), "selection_received",
6538 GTK_SIGNAL_FUNC (selection_received), NULL);
6540 gtk_widget_show (button);
6541 gtk_widget_show (window);
6549 <!-- ----------------------------------------------------------------- -->
6550 <sect1> Supplying the selection
6554 Supplying the selection is a bit more complicated. You must register
6555 handlers that will be called when your selection is requested. For
6556 each selection/target pair you will handle, you make a call to:
6559 void gtk_selection_add_handler (GtkWidget *widget,
6562 GtkSelectionFunction function,
6563 GtkRemoveFunction remove_func,
6567 <tt/widget/, <tt/selection/, and <tt/target/ identify the requests
6568 this handler will manage. <tt/remove_func/ if not
6569 NULL, will be called when the signal handler is removed. This is
6570 useful, for instance, for interpreted languages which need to
6571 keep track of a reference count for <tt/data/.
6574 The callback function has the signature:
6577 typedef void (*GtkSelectionFunction) (GtkWidget *widget,
6578 GtkSelectionData *selection_data,
6583 The GtkSelectionData is the same as above, but this time, we're
6584 responsible for filling in the fields <tt/type/, <tt/format/,
6585 <tt/data/, and <tt/length/. (The <tt/format/ field is actually
6586 important here - the X server uses it to figure out whether the data
6587 needs to be byte-swapped or not. Usually it will be 8 - <em/i.e./ a
6588 character - or 32 - <em/i.e./ a. integer.) This is done by calling the
6592 void gtk_selection_data_set (GtkSelectionData *selection_data,
6599 This function takes care of properly making a copy of the data so that
6600 you don't have to worry about keeping it around. (You should not fill
6601 in the fields of the GtkSelectionData structure by hand.)
6604 When prompted by the user, you claim ownership of the selection by
6608 gint gtk_selection_owner_set (GtkWidget *widget,
6613 If another application claims ownership of the selection, you will
6614 receive a "selection_clear_event".
6616 As an example of supplying the selection, the following program adds
6617 selection functionality to a toggle button. When the toggle button is
6618 depressed, the program claims the primary selection. The only target
6619 supported (aside from certain targets like "TARGETS" supplied by GTK
6620 itself), is the "STRING" target. When this target is requested, a
6621 string representation of the time is returned.
6624 /* setselection.c */
6626 #include <gtk/gtk.h>
6629 /* Callback when the user toggles the selection */
6631 selection_toggled (GtkWidget *widget, gint *have_selection)
6633 if (GTK_TOGGLE_BUTTON(widget)->active)
6635 *have_selection = gtk_selection_owner_set (widget,
6636 GDK_SELECTION_PRIMARY,
6638 /* if claiming the selection failed, we return the button to
6640 if (!*have_selection)
6641 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
6645 if (*have_selection)
6647 /* Before clearing the selection by setting the owner to NULL,
6648 we check if we are the actual owner */
6649 if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
6650 gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY,
6652 *have_selection = FALSE;
6657 /* Called when another application claims the selection */
6659 selection_clear (GtkWidget *widget, GdkEventSelection *event,
6660 gint *have_selection)
6662 *have_selection = FALSE;
6663 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
6668 /* Supplies the current time as the selection. */
6670 selection_handle (GtkWidget *widget,
6671 GtkSelectionData *selection_data,
6675 time_t current_time;
6677 current_time = time (NULL);
6678 timestr = asctime (localtime(&current_time));
6679 /* When we return a single string, it should not be null terminated.
6680 That will be done for us */
6682 gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
6683 8, timestr, strlen(timestr));
6687 main (int argc, char *argv[])
6691 GtkWidget *selection_button;
6693 static int have_selection = FALSE;
6695 gtk_init (&argc, &argv);
6697 /* Create the toplevel window */
6699 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6700 gtk_window_set_title (GTK_WINDOW (window), "Event Box");
6701 gtk_container_border_width (GTK_CONTAINER (window), 10);
6703 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6704 GTK_SIGNAL_FUNC (gtk_exit), NULL);
6706 /* Create a toggle button to act as the selection */
6708 selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
6709 gtk_container_add (GTK_CONTAINER (window), selection_button);
6710 gtk_widget_show (selection_button);
6712 gtk_signal_connect (GTK_OBJECT(selection_button), "toggled",
6713 GTK_SIGNAL_FUNC (selection_toggled), &have_selection);
6714 gtk_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
6715 GTK_SIGNAL_FUNC (selection_clear), &have_selection);
6717 gtk_selection_add_handler (selection_button, GDK_SELECTION_PRIMARY,
6718 GDK_SELECTION_TYPE_STRING,
6719 selection_handle, NULL);
6721 gtk_widget_show (selection_button);
6722 gtk_widget_show (window);
6731 <!-- ***************************************************************** -->
6732 <sect>glib<label id="sec_glib">
6733 <!-- ***************************************************************** -->
6736 glib provides many useful functions and definitions available for use
6738 and GTK applications. I will list them all here with a brief explanation.
6739 Many are duplicates of standard libc functions so I won't go into
6740 detail on those. This is mostly to be used as a reference, so you know what is
6743 <!-- ----------------------------------------------------------------- -->
6746 Definitions for the extremes of many of the standard types are:
6761 Also, the following typedefs. The ones left unspecified are dynamically set
6762 depending on the architecture. Remember to avoid counting on the size of a
6763 pointer if you want to be portable! Eg, a pointer on an Alpha is 8 bytes, but 4
6773 unsigned char guchar;
6774 unsigned short gushort;
6775 unsigned long gulong;
6780 long double gldouble;
6792 <!-- ----------------------------------------------------------------- -->
6793 <sect1>Doubly Linked Lists
6795 The following functions are used to create, manage, and destroy doubly
6796 linked lists. I assume you know what linked lists are, as it is beyond the scope
6797 of this document to explain them. Of course, it's not required that you
6798 know these for general use of GTK, but they are nice to know.
6801 GList* g_list_alloc (void);
6803 void g_list_free (GList *list);
6805 void g_list_free_1 (GList *list);
6807 GList* g_list_append (GList *list,
6810 GList* g_list_prepend (GList *list,
6813 GList* g_list_insert (GList *list,
6817 GList* g_list_remove (GList *list,
6820 GList* g_list_remove_link (GList *list,
6823 GList* g_list_reverse (GList *list);
6825 GList* g_list_nth (GList *list,
6828 GList* g_list_find (GList *list,
6831 GList* g_list_last (GList *list);
6833 GList* g_list_first (GList *list);
6835 gint g_list_length (GList *list);
6837 void g_list_foreach (GList *list,
6839 gpointer user_data);
6842 <!-- ----------------------------------------------------------------- -->
6843 <sect1>Singly Linked Lists
6845 Many of the above functions for singly linked lists are identical to the
6846 above. Here is a complete list:
6848 GSList* g_slist_alloc (void);
6850 void g_slist_free (GSList *list);
6852 void g_slist_free_1 (GSList *list);
6854 GSList* g_slist_append (GSList *list,
6857 GSList* g_slist_prepend (GSList *list,
6860 GSList* g_slist_insert (GSList *list,
6864 GSList* g_slist_remove (GSList *list,
6867 GSList* g_slist_remove_link (GSList *list,
6870 GSList* g_slist_reverse (GSList *list);
6872 GSList* g_slist_nth (GSList *list,
6875 GSList* g_slist_find (GSList *list,
6878 GSList* g_slist_last (GSList *list);
6880 gint g_slist_length (GSList *list);
6882 void g_slist_foreach (GSList *list,
6884 gpointer user_data);
6888 <!-- ----------------------------------------------------------------- -->
6889 <sect1>Memory Management
6892 gpointer g_malloc (gulong size);
6895 This is a replacement for malloc(). You do not need to check the return
6896 vaule as it is done for you in this function.
6899 gpointer g_malloc0 (gulong size);
6902 Same as above, but zeroes the memory before returning a pointer to it.
6905 gpointer g_realloc (gpointer mem,
6909 Relocates "size" bytes of memory starting at "mem". Obviously, the memory should have been
6910 previously allocated.
6913 void g_free (gpointer mem);
6916 Frees memory. Easy one.
6919 void g_mem_profile (void);
6922 Dumps a profile of used memory, but requries that you add #define
6923 MEM_PROFILE to the top of glib/gmem.c and re-make and make install.
6926 void g_mem_check (gpointer mem);
6929 Checks that a memory location is valid. Requires you add #define
6930 MEM_CHECK to the top of gmem.c and re-make and make install.
6932 <!-- ----------------------------------------------------------------- -->
6938 GTimer* g_timer_new (void);
6940 void g_timer_destroy (GTimer *timer);
6942 void g_timer_start (GTimer *timer);
6944 void g_timer_stop (GTimer *timer);
6946 void g_timer_reset (GTimer *timer);
6948 gdouble g_timer_elapsed (GTimer *timer,
6949 gulong *microseconds);
6952 <!-- ----------------------------------------------------------------- -->
6953 <sect1>String Handling
6955 A whole mess of string handling functions. They all look very interesting, and
6956 probably better for many purposes than the standard C string functions, but
6957 require documentation.
6960 GString* g_string_new (gchar *init);
6961 void g_string_free (GString *string,
6964 GString* g_string_assign (GString *lval,
6967 GString* g_string_truncate (GString *string,
6970 GString* g_string_append (GString *string,
6973 GString* g_string_append_c (GString *string,
6976 GString* g_string_prepend (GString *string,
6979 GString* g_string_prepend_c (GString *string,
6982 void g_string_sprintf (GString *string,
6986 void g_string_sprintfa (GString *string,
6991 <!-- ----------------------------------------------------------------- -->
6992 <sect1>Utility and Error Functions
6995 gchar* g_strdup (const gchar *str);
6998 Replacement strdup function. Copies the
6999 original strings contents to newly allocated memory, and returns a pointer to it.
7002 gchar* g_strerror (gint errnum);
7005 I recommend using this for all error messages. It's much nicer, and more
7006 portable than perror() or others. The output is usually of the form:
7009 program name:function that failed:file or further description:strerror
7012 Here's an example of one such call used in our hello_world program:
7015 g_print("hello_world:open:%s:%s\n", filename, g_strerror(errno));
7019 void g_error (gchar *format, ...);
7022 Prints an error message. The format is just like printf, but it
7023 prepends "** ERROR **: " to your message, and exits the program.
7024 Use only for fatal errors.
7027 void g_warning (gchar *format, ...);
7030 Same as above, but prepends "** WARNING **: ", and does not exit the
7034 void g_message (gchar *format, ...);
7037 Prints "message: " prepended to the string you pass in.
7040 void g_print (gchar *format, ...);
7043 Replacement for printf().
7045 And our last function:
7048 gchar* g_strsignal (gint signum);
7051 Prints out the name of the Unix system signal given the signal number.
7052 Useful in generic signal handling functions.
7054 All of the above are more or less just stolen from glib.h. If anyone cares
7055 to document any function, just send me an email!
7057 <!-- ***************************************************************** -->
7058 <sect>GTK's rc Files
7059 <!-- ***************************************************************** -->
7062 GTK has it's own way of dealing with application defaults, by using rc
7063 files. These can be used to set the colors of just about any widget, and
7064 can also be used to tile pixmaps onto the background of some widgets.
7066 <!-- ----------------------------------------------------------------- -->
7067 <sect1>Functions For rc Files
7069 When your application starts, you should include a call to:
7071 void gtk_rc_parse (char *filename);
7074 Passing in the filename of your rc file. This will cause GTK to parse this
7075 file, and use the style settings for the widget types defined there.
7077 If you wish to have a special set of widgets that can take on a different
7078 style from others, or any other logical division of widgets, use a call to:
7080 void gtk_widget_set_name (GtkWidget *widget,
7084 Passing your newly created widget as the first argument, and the name
7085 you wish to give it as the second. This will allow you to change the
7086 attributes of this widget by name through the rc file.
7088 If we use a call something like this:
7091 button = gtk_button_new_with_label ("Special Button");
7092 gtk_widget_set_name (button, "special button");
7095 Then this button is given the name "special button" and may be addressed by
7096 name in the rc file as "special button.GtkButton". [<--- Verify ME!]
7098 The example rc file below, sets the properties of the main window, and lets
7099 all children of that main window inherit the style described by the "main
7100 button" style. The code used in the application is:
7103 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7104 gtk_widget_set_name (window, "main window");
7107 And then the style is defined in the rc file using:
7110 widget "main window.*GtkButton*" style "main_button"
7113 Which sets all the GtkButton widgets in the "main window" to the
7114 "main_buttons" style as defined in the rc file.
7116 As you can see, this is a fairly powerful and flexible system. Use your
7117 imagination as to how best to take advantage of this.
7119 <!-- ----------------------------------------------------------------- -->
7120 <sect1>GTK's rc File Format
7122 The format of the GTK file is illustrated in the example below. This is
7123 the testgtkrc file from the GTK distribution, but I've added a
7124 few comments and things. You may wish to include this explanation
7125 your application to allow the user to fine tune his application.
7127 There are several directives to change the attributes of a widget.
7129 <item>fg - Sets the foreground color of a widget.
7130 <item>bg - Sets the background color of a widget.
7131 <item>bg_pixmap - Sets the background of a widget to a tiled pixmap.
7132 <item>font - Sets the font to be used with the given widget.
7135 In addition to this, there are several states a widget can be in, and you
7136 can set different colors, pixmaps and fonts for each state. These states are:
7138 <item>NORMAL - The normal state of a widget, without the mouse over top of
7139 it, and not being pressed etc.
7140 <item>PRELIGHT - When the mouse is over top of the widget, colors defined
7141 using this state will be in effect.
7142 <item>ACTIVE - When the widget is pressed or clicked it will be active, and
7143 the attributes assigned by this tag will be in effect.
7144 <item>INSENSITIVE - When a widget is set insensitive, and cannot be
7145 activated, it will take these attributes.
7146 <item>SELECTED - When an object is selected, it takes these attributes.
7149 When using the "fg" and "bg" keywords to set the colors of widgets, the
7152 fg[<STATE>] = { Red, Green, Blue }
7155 Where STATE is one of the above states (PRELIGHT, ACTIVE etc), and the Red,
7156 Green and Blue are values in the range of 0 - 1.0, { 1.0, 1.0, 1.0 } being
7158 They must be in float form, or they will register as 0, so a straight
7159 "1" will not work, it must
7160 be "1.0". A straight "0" is fine because it doesn't matter if it's not
7161 recognized. Unrecognized values are set to 0.
7163 bg_pixmap is very similar to the above, except the colors are replaced by a
7166 pixmap_path is a list of paths seperated by ":"'s. These paths will be
7167 searched for any pixmap you specify.
7170 The font directive is simply:
7172 font = "<font name>"
7175 Where the only hard part is figuring out the font string. Using xfontsel or
7176 similar utility should help.
7178 The "widget_class" sets the style of a class of widgets. These classes are
7179 listed in the widget overview on the class hierarchy.
7181 The "widget" directive sets a specificaly named set of widgets to a
7182 given style, overriding any style set for the given widget class.
7183 These widgets are registered inside the application using the
7184 gtk_widget_set_name() call. This allows you to specify the attributes of a
7185 widget on a per widget basis, rather than setting the attributes of an
7186 entire widget class. I urge you to document any of these special widgets so
7187 users may customize them.
7189 When the keyword "<tt>parent</>" is used as an attribute, the widget will take on
7190 the attributes of it's parent in the application.
7192 When defining a style, you may assign the attributes of a previously defined
7193 style to this new one.
7195 style "main_button" = "button"
7197 font = "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*"
7198 bg[PRELIGHT] = { 0.75, 0, 0 }
7202 This example takes the "button" style, and creates a new "main_button" style
7203 simply by changing the font and prelight background color of the "button"
7206 Of course, many of these attributes don't apply to all widgets. It's a
7207 simple matter of common sense really. Anything that could apply, should.
7209 <!-- ----------------------------------------------------------------- -->
7210 <sect1>Example rc file
7214 # pixmap_path "<dir 1>:<dir 2>:<dir 3>:..."
7216 pixmap_path "/usr/include/X11R6/pixmaps:/home/imain/pixmaps"
7218 # style <name> [= <name>]
7223 # widget <widget_set> style <style_name>
7224 # widget_class <widget_class_set> style <style_name>
7227 # Here is a list of all the possible states. Note that some do not apply to
7230 # NORMAL - The normal state of a widget, without the mouse over top of
7231 # it, and not being pressed etc.
7233 # PRELIGHT - When the mouse is over top of the widget, colors defined
7234 # using this state will be in effect.
7236 # ACTIVE - When the widget is pressed or clicked it will be active, and
7237 # the attributes assigned by this tag will be in effect.
7239 # INSENSITIVE - When a widget is set insensitive, and cannot be
7240 # activated, it will take these attributes.
7242 # SELECTED - When an object is selected, it takes these attributes.
7244 # Given these states, we can set the attributes of the widgets in each of
7245 # these states using the following directives.
7247 # fg - Sets the foreground color of a widget.
7248 # fg - Sets the background color of a widget.
7249 # bg_pixmap - Sets the background of a widget to a tiled pixmap.
7250 # font - Sets the font to be used with the given widget.
7253 # This sets a style called "button". The name is not really important, as
7254 # it is assigned to the actual widgets at the bottom of the file.
7258 #This sets the padding around the window to the pixmap specified.
7259 #bg_pixmap[<STATE>] = "<pixmap filename>"
7260 bg_pixmap[NORMAL] = "warning.xpm"
7265 #Sets the foreground color (font color) to red when in the "NORMAL"
7268 fg[NORMAL] = { 1.0, 0, 0 }
7270 #Sets the background pixmap of this widget to that of it's parent.
7271 bg_pixmap[NORMAL] = "<parent>"
7276 # This shows all the possible states for a button. The only one that
7277 # doesn't apply is the SELECTED state.
7279 fg[PRELIGHT] = { 0, 1.0, 1.0 }
7280 bg[PRELIGHT] = { 0, 0, 1.0 }
7281 bg[ACTIVE] = { 1.0, 0, 0 }
7282 fg[ACTIVE] = { 0, 1.0, 0 }
7283 bg[NORMAL] = { 1.0, 1.0, 0 }
7284 fg[NORMAL] = { .99, 0, .99 }
7285 bg[INSENSITIVE] = { 1.0, 1.0, 1.0 }
7286 fg[INSENSITIVE] = { 1.0, 0, 1.0 }
7289 # In this example, we inherit the attributes of the "button" style and then
7290 # override the font and background color when prelit to create a new
7291 # "main_button" style.
7293 style "main_button" = "button"
7295 font = "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*"
7296 bg[PRELIGHT] = { 0.75, 0, 0 }
7299 style "toggle_button" = "button"
7301 fg[NORMAL] = { 1.0, 0, 0 }
7302 fg[ACTIVE] = { 1.0, 0, 0 }
7304 # This sets the background pixmap of the toggle_button to that of it's
7305 # parent widget (as defined in the application).
7306 bg_pixmap[NORMAL] = "<parent>"
7311 bg_pixmap[NORMAL] = "marble.xpm"
7312 fg[NORMAL] = { 1.0, 1.0, 1.0 }
7317 font = "-adobe-helvetica-medium-r-normal--*-80-*-*-*-*-*-*"
7320 # pixmap_path "~/.pixmaps"
7322 # These set the widget types to use the styles defined above.
7323 # The widget types are listed in the class hierarchy, but could probably be
7324 # just listed in this document for the users reference.
7326 widget_class "GtkWindow" style "window"
7327 widget_class "GtkDialog" style "window"
7328 widget_class "GtkFileSelection" style "window"
7329 widget_class "*Gtk*Scale" style "scale"
7330 widget_class "*GtkCheckButton*" style "toggle_button"
7331 widget_class "*GtkRadioButton*" style "toggle_button"
7332 widget_class "*GtkButton*" style "button"
7333 widget_class "*Ruler" style "ruler"
7334 widget_class "*GtkText" style "text"
7336 # This sets all the buttons that are children of the "main window" to
7337 # the main_buton style. These must be documented to be taken advantage of.
7338 widget "main window.*GtkButton*" style "main_button"
7341 <!-- ***************************************************************** -->
7342 <sect>Writing Your Own Widgets
7343 <!-- ***************************************************************** -->
7345 <!-- ----------------------------------------------------------------- -->
7348 Although the GTK distribution comes with many types of widgets that
7349 should cover most basic needs, there may come a time when you need to
7350 create your own new widget type. Since GTK uses widget inheretence
7351 extensively, and there is already a widget that
7352 is close to what you want, it is often possible to make a useful new widget type in
7353 just a few lines of code. But before starting work on a new widget, check
7354 around first to make sure that someone has not already written
7355 it. This will prevent duplication of effort and keep the number of
7356 GTK widgets out there to a minimum, which will help keep both the code
7357 and the interface of different applications consistent. As a flip side
7358 to this, once you finish your widget, announce it to the world so
7359 other people can benefit. The best place to do this is probably the
7362 Complete sources for the example widgets are available at the place you
7363 got this tutorial, or from:
7365 <htmlurl url="http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial"
7366 name="http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial">
7369 <!-- ----------------------------------------------------------------- -->
7370 <sect1> The Anatomy Of A Widget
7373 In order to create a new widget, it is important to have an
7374 understanding of how GTK objects work. This section is just meant as a
7375 brief overview. See the reference documentation for the details.
7378 GTK widgets are implemented in an object oriented fashion. However,
7379 they are implemented in standard C. This greatly improves portability
7380 and stability over using current generation C++ compilers; however,
7381 it does mean that the widget writer has to pay attention to some of
7382 the implementation details. The information common to all instances of
7383 one class of widgets (e.g., to all Button widgets) is stored in the
7384 <em>class structure</em>. There is only one copy of this in
7385 which is stored information about the class's signals
7386 (which act like virtual functions in C). To support inheritance, the
7387 first field in the class structure must be a copy of the parent's
7388 class structure. The declaration of the class structure of GtkButtton
7392 struct _GtkButtonClass
7394 GtkContainerClass parent_class;
7396 void (* pressed) (GtkButton *button);
7397 void (* released) (GtkButton *button);
7398 void (* clicked) (GtkButton *button);
7399 void (* enter) (GtkButton *button);
7400 void (* leave) (GtkButton *button);
7405 When a button is treated as a container (for instance, when it is
7406 resized), its class structure can be cast to GtkContainerClass, and
7407 the relevant fields used to handle the signals.
7410 There is also a structure for each widget that is created on a
7411 per-instance basis. This structure has fields to store information that
7412 is different for each instance of the widget. We'll call this
7413 structure the <em>object structure</em>. For the Button class, it looks
7419 GtkContainer container;
7423 guint in_button : 1;
7424 guint button_down : 1;
7429 Note that, similar to the class structure, the first field is the
7430 object structure of the parent class, so that this structure can be
7431 cast to the parent class's object structure as needed.
7433 <!-- ----------------------------------------------------------------- -->
7434 <sect1> Creating a Composite widget
7436 <!-- ----------------------------------------------------------------- -->
7437 <sect2> Introduction
7440 One type of widget that you may be interested in creating is a
7441 widget that is merely an aggregate of other GTK widgets. This type of
7442 widget does nothing that couldn't be done without creating new
7443 widgets, but provides a convenient way of packaging user interface
7444 elements for reuse. The FileSelection and ColorSelection widgets in
7445 the standard distribution are examples of this type of widget.
7448 The example widget that we'll create in this section is the Tictactoe
7449 widget, a 3x3 array of toggle buttons which triggers a signal when all
7450 three buttons in a row, column, or on one of the diagonals are
7453 <!-- ----------------------------------------------------------------- -->
7454 <sect2> Choosing a parent class
7457 The parent class for a composite widget is typically the container
7458 class that holds all of the elements of the composite widget. For
7459 example, the parent class of the FileSelection widget is the
7460 Dialog class. Since our buttons will be arranged in a table, it
7461 might seem natural to make our parent class the GtkTable
7462 class. Unfortunately, this turns out not to work. The creation of a
7463 widget is divided among two functions - a <tt/WIDGETNAME_new()/
7464 function that the user calls, and a <tt/WIDGETNAME_init()/ function
7465 which does the basic work of initializing the widget which is
7466 independent of the arguments passed to the <tt/_new()/
7467 function. Descendent widgets only call the <tt/_init/ function of
7468 their parent widget. But this division of labor doesn't work well for
7469 tables, which when created, need to know the number of rows and
7470 columns in the table. Unless we want to duplicate most of the
7471 functionality of <tt/gtk_table_new()/ in our Tictactoe widget, we had
7472 best avoid deriving it from GtkTable. For that reason, we derive it
7473 from GtkVBox instead, and stick our table inside the VBox.
7475 <!-- ----------------------------------------------------------------- -->
7476 <sect2> The header file
7479 Each widget class has a header file which declares the object and
7480 class structures for that widget, along with public functions.
7481 A couple of features are worth pointing out. To prevent duplicate
7482 definitions, we wrap the entire header file in:
7485 #ifndef __TICTACTOE_H__
7486 #define __TICTACTOE_H__
7490 #endif /* __TICTACTOE_H__ */
7493 And to keep C++ programs that include the header file happy, in:
7498 #endif /* __cplusplus */
7504 #endif /* __cplusplus */
7507 Along with the functions and structures, we declare three standard
7508 macros in our header file, <tt/TICTACTOE(obj)/,
7509 <tt/TICTACTOE_CLASS(klass)/, and <tt/IS_TICTACTOE(obj)/, which cast a
7510 pointer into a pointer to the object or class structure, and check
7511 if an object is a Tictactoe widget respectively.
7514 Here is the complete header file:
7519 #ifndef __TICTACTOE_H__
7520 #define __TICTACTOE_H__
7522 #include <gdk/gdk.h>
7523 #include <gtk/gtkvbox.h>
7527 #endif /* __cplusplus */
7529 #define TICTACTOE(obj) GTK_CHECK_CAST (obj, tictactoe_get_type (), Tictactoe)
7530 #define TICTACTOE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, tictactoe_get_type (), TictactoeClass)
7531 #define IS_TICTACTOE(obj) GTK_CHECK_TYPE (obj, tictactoe_get_type ())
7534 typedef struct _Tictactoe Tictactoe;
7535 typedef struct _TictactoeClass TictactoeClass;
7541 GtkWidget *buttons[3][3];
7544 struct _TictactoeClass
7546 GtkVBoxClass parent_class;
7548 void (* tictactoe) (Tictactoe *ttt);
7551 guint tictactoe_get_type (void);
7552 GtkWidget* tictactoe_new (void);
7553 void tictactoe_clear (Tictactoe *ttt);
7557 #endif /* __cplusplus */
7559 #endif /* __TICTACTOE_H__ */
7563 <!-- ----------------------------------------------------------------- -->
7564 <sect2> The <tt/_get_type()/ function.
7567 We now continue on to the implementation of our widget. A core
7568 function for every widget is the function
7569 <tt/WIDGETNAME_get_type()/. This function, when first called, tells
7570 GTK about the widget class, and gets an ID that uniquely identifies
7571 the widget class. Upon subsequent calls, it just returns the ID.
7575 tictactoe_get_type ()
7577 static guint ttt_type = 0;
7581 GtkTypeInfo ttt_info =
7585 sizeof (TictactoeClass),
7586 (GtkClassInitFunc) tictactoe_class_init,
7587 (GtkObjectInitFunc) tictactoe_init,
7588 (GtkArgSetFunc) NULL,
7589 (GtkArgGetFunc) NULL
7592 ttt_type = gtk_type_unique (gtk_vbox_get_type (), &ttt_info);
7600 The GtkTypeInfo structure has the following definition:
7608 GtkClassInitFunc class_init_func;
7609 GtkObjectInitFunc object_init_func;
7610 GtkArgSetFunc arg_set_func;
7611 GtkArgGetFunc arg_get_func;
7616 The fields of this structure are pretty self-explanatory. We'll ignore
7617 the <tt/arg_set_func/ and <tt/arg_get_func/ fields here: they have an important,
7619 unimplemented, role in allowing widget options to be conveniently set
7620 from interpreted languages. Once GTK has a correctly filled in copy of
7621 this structure, it knows how to create objects of a particular widget
7624 <!-- ----------------------------------------------------------------- -->
7625 <sect2> The <tt/_class_init()/ function
7628 The <tt/WIDGETNAME_class_init()/ function initializes the fields of
7629 the widget's class structure, and sets up any signals for the
7630 class. For our Tictactoe widget it looks like:
7639 static gint tictactoe_signals[LAST_SIGNAL] = { 0 };
7642 tictactoe_class_init (TictactoeClass *class)
7644 GtkObjectClass *object_class;
7646 object_class = (GtkObjectClass*) class;
7648 tictactoe_signals[TICTACTOE_SIGNAL] = gtk_signal_new ("tictactoe",
7651 GTK_SIGNAL_OFFSET (TictactoeClass, tictactoe),
7652 gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
7655 gtk_object_class_add_signals (object_class, tictactoe_signals, LAST_SIGNAL);
7657 class->tictactoe = NULL;
7662 Our widget has just one signal, the ``tictactoe'' signal that is
7663 invoked when a row, column, or diagonal is completely filled in. Not
7664 every composite widget needs signals, so if you are reading this for
7665 the first time, you may want to skip to the next section now, as
7666 things are going to get a bit complicated.
7671 gint gtk_signal_new (const gchar *name,
7672 GtkSignalRunType run_type,
7673 GtkType object_type,
7674 gint function_offset,
7675 GtkSignalMarshaller marshaller,
7681 Creates a new signal. The parameters are:
7684 <item> <tt/name/: The name of the signal.
7685 <item> <tt/run_type/: Whether the default handler runs before or after
7686 user handlers. Usually this will be <tt/GTK_RUN_FIRST/, or <tt/GTK_RUN_LAST/,
7687 although there are other possibilities.
7688 <item> <tt/object_type/: The ID of the object that this signal applies
7689 to. (It will also apply to that objects descendents)
7690 <item> <tt/function_offset/: The offset within the class structure of
7691 a pointer to the default handler.
7692 <item> <tt/marshaller/: A function that is used to invoke the signal
7693 handler. For signal handlers that have no arguments other than the
7694 object that emitted the signal and user data, we can use the
7695 pre-supplied marshaller function <tt/gtk_signal_default_marshaller/.
7696 <item> <tt/return_val/: The type of the return val.
7697 <item> <tt/nparams/: The number of parameters of the signal handler
7698 (other than the two default ones mentioned above)
7699 <item> <tt/.../: The types of the parameters.
7702 When specifying types, the <tt/GtkType/ enumeration is used:
7727 /* it'd be great if the next two could be removed eventually */
7729 GTK_TYPE_C_CALLBACK,
7733 } GtkFundamentalType;
7737 <tt/gtk_signal_new()/ returns a unique integer identifier for the
7738 signal, that we store in the <tt/tictactoe_signals/ array, which we
7739 index using an enumeration. (Conventionally, the enumeration elements
7740 are the signal name, uppercased, but here there would be a conflict
7741 with the <tt/TICTACTOE()/ macro, so we called it <tt/TICTACTOE_SIGNAL/
7744 After creating our signals, we need to tell GTK to associate our
7745 signals with the Tictactoe class. We do that by calling
7746 <tt/gtk_object_class_add_signals()/. We then set the pointer which
7747 points to the default handler for the ``tictactoe'' signal to NULL,
7748 indicating that there is no default action.
7750 <!-- ----------------------------------------------------------------- -->
7751 <sect2> The <tt/_init()/ function.
7755 Each widget class also needs a function to initialize the object
7756 structure. Usually, this function has the fairly limited role of
7757 setting the fields of the structure to default values. For composite
7758 widgets, however, this function also creates the component widgets.
7762 tictactoe_init (Tictactoe *ttt)
7767 table = gtk_table_new (3, 3, TRUE);
7768 gtk_container_add (GTK_CONTAINER(ttt), table);
7769 gtk_widget_show (table);
7774 ttt->buttons[i][j] = gtk_toggle_button_new ();
7775 gtk_table_attach_defaults (GTK_TABLE(table), ttt->buttons[i][j],
7777 gtk_signal_connect (GTK_OBJECT (ttt->buttons[i][j]), "toggled",
7778 GTK_SIGNAL_FUNC (tictactoe_toggle), ttt);
7779 gtk_widget_set_usize (ttt->buttons[i][j], 20, 20);
7780 gtk_widget_show (ttt->buttons[i][j]);
7785 <!-- ----------------------------------------------------------------- -->
7786 <sect2> And the rest...
7790 There is one more function that every widget (except for base widget
7791 types like GtkBin that cannot be instantiated) needs to have - the
7792 function that the user calls to create an object of that type. This is
7793 conventionally called <tt/WIDGETNAME_new()/. In some
7794 widgets, though not for the Tictactoe widgets, this function takes
7795 arguments, and does some setup based on the arguments. The other two
7796 functions are specific to the Tictactoe widget.
7799 <tt/tictactoe_clear()/ is a public function that resets all the
7800 buttons in the widget to the up position. Note the use of
7801 <tt/gtk_signal_handler_block_by_data()/ to keep our signal handler for
7802 button toggles from being triggered unnecessarily.
7805 <tt/tictactoe_toggle()/ is the signal handler that is invoked when the
7806 user clicks on a button. It checks to see if there are any winning
7807 combinations that involve the toggled button, and if so, emits
7808 the "tictactoe" signal.
7814 return GTK_WIDGET ( gtk_type_new (tictactoe_get_type ()));
7818 tictactoe_clear (Tictactoe *ttt)
7825 gtk_signal_handler_block_by_data (GTK_OBJECT(ttt->buttons[i][j]), ttt);
7826 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (ttt->buttons[i][j]),
7828 gtk_signal_handler_unblock_by_data (GTK_OBJECT(ttt->buttons[i][j]), ttt);
7833 tictactoe_toggle (GtkWidget *widget, Tictactoe *ttt)
7837 static int rwins[8][3] = { { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 },
7838 { 0, 1, 2 }, { 0, 1, 2 }, { 0, 1, 2 },
7839 { 0, 1, 2 }, { 0, 1, 2 } };
7840 static int cwins[8][3] = { { 0, 1, 2 }, { 0, 1, 2 }, { 0, 1, 2 },
7841 { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 },
7842 { 0, 1, 2 }, { 2, 1, 0 } };
7853 success = success &&
7854 GTK_TOGGLE_BUTTON(ttt->buttons[rwins[k][i]][cwins[k][i]])->active;
7856 ttt->buttons[rwins[k][i]][cwins[k][i]] == widget;
7859 if (success && found)
7861 gtk_signal_emit (GTK_OBJECT (ttt),
7862 tictactoe_signals[TICTACTOE_SIGNAL]);
7871 And finally, an example program using our Tictactoe widget:
7874 #include <gtk/gtk.h>
7875 #include "tictactoe.h"
7877 /* Invoked when a row, column or diagonal is completed */
7879 win (GtkWidget *widget, gpointer data)
7882 tictactoe_clear (TICTACTOE (widget));
7886 main (int argc, char *argv[])
7891 gtk_init (&argc, &argv);
7893 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7895 gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
7897 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7898 GTK_SIGNAL_FUNC (gtk_exit), NULL);
7900 gtk_container_border_width (GTK_CONTAINER (window), 10);
7902 /* Create a new Tictactoe widget */
7903 ttt = tictactoe_new ();
7904 gtk_container_add (GTK_CONTAINER (window), ttt);
7905 gtk_widget_show (ttt);
7907 /* And attach to its "tictactoe" signal */
7908 gtk_signal_connect (GTK_OBJECT (ttt), "tictactoe",
7909 GTK_SIGNAL_FUNC (win), NULL);
7911 gtk_widget_show (window);
7920 <!-- ----------------------------------------------------------------- -->
7921 <sect1> Creating a widget from scratch.
7923 <!-- ----------------------------------------------------------------- -->
7924 <sect2> Introduction
7928 In this section, we'll learn more about how widgets display themselves
7929 on the screen and interact with events. As an example of this, we'll
7930 create an analog dial widget with a pointer that the user can drag to
7933 <!-- ----------------------------------------------------------------- -->
7934 <sect2> Displaying a widget on the screen
7937 There are several steps that are involved in displaying on the screen.
7938 After the widget is created with a call to <tt/WIDGETNAME_new()/,
7939 several more functions are needed:
7942 <item> <tt/WIDGETNAME_realize()/ is responsible for creating an X
7943 window for the widget if it has one.
7944 <item> <tt/WIDGETNAME_map()/ is invoked after the user calls
7945 <tt/gtk_widget_show()/. It is responsible for making sure the widget
7946 is actually drawn on the screen (<em/mapped/). For a container class,
7947 it must also make calls to <tt/map()/> functions of any child widgets.
7948 <item> <tt/WIDGETNAME_draw()/ is invoked when <tt/gtk_widget_draw()/
7949 is called for the widget or one of its ancestors. It makes the actual
7950 calls to the drawing functions to draw the widget on the screen. For
7951 container widgets, this function must make calls to
7952 <tt/gtk_widget_draw()/ for its child widgets.
7953 <item> <tt/WIDGETNAME_expose()/ is a handler for expose events for the
7954 widget. It makes the necessary calls to the drawing functions to draw
7955 the exposed portion on the screen. For container widgets, this
7956 function must generate expose events for its child widgets which don't
7957 have their own windows. (If they have their own windows, then X will
7958 generate the necessary expose events)
7962 You might notice that the last two functions are quite similar - each
7963 is responsible for drawing the widget on the screen. In fact many
7964 types of widgets don't really care about the difference between the
7965 two. The default <tt/draw()/ function in the widget class simply
7966 generates a synthetic expose event for the redrawn area. However, some
7967 types of widgets can save work by distinguishing between the two
7968 functions. For instance, if a widget has multiple X windows, then
7969 since expose events identify the exposed window, it can redraw only
7970 the affected window, which is not possible for calls to <tt/draw()/.
7973 Container widgets, even if they don't care about the difference for
7974 themselves, can't simply use the default <tt/draw()/ function because
7975 their child widgets might care about the difference. However,
7976 it would be wasteful to duplicate the drawing code between the two
7977 functions. The convention is that such widgets have a function called
7978 <tt/WIDGETNAME_paint()/ that does the actual work of drawing the
7979 widget, that is then called by the <tt/draw()/ and <tt/expose()/
7983 In our example approach, since the dial widget is not a container
7984 widget, and only has a single window, we can take the simplest
7985 approach and use the default <tt/draw()/ function and only implement
7986 an <tt/expose()/ function.
7988 <!-- ----------------------------------------------------------------- -->
7989 <sect2> The origins of the Dial Widget
7992 Just as all land animals are just variants on the first amphibian that
7993 crawled up out of the mud, Gtk widgets tend to start off as variants
7994 of some other, previously written widget. Thus, although this section
7995 is entilted ``Creating a Widget from Scratch'', the Dial widget really
7996 began with the source code for the Range widget. This was picked as a
7997 starting point because it would be nice if our Dial had the same
7998 interface as the Scale widgets which are just specialized descendents
7999 of the Range widget. So, though the source code is presented below in
8000 finished form, it should not be implied that it was written, <em>deus
8001 ex machina</em> in this fashion. Also, if you aren't yet familiar with
8002 how scale widgets work from the application writer's point of view, it
8003 would be a good idea to look them over before continuing.
8005 <!-- ----------------------------------------------------------------- -->
8009 Quite a bit of our widget should look pretty familiar from the
8010 Tictactoe widget. First, we have a header file:
8013 /* GTK - The GIMP Toolkit
8014 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
8016 * This library is free software; you can redistribute it and/or
8017 * modify it under the terms of the GNU Library General Public
8018 * License as published by the Free Software Foundation; either
8019 * version 2 of the License, or (at your option) any later version.
8021 * This library is distributed in the hope that it will be useful,
8022 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8023 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
8024 * Library General Public License for more details.
8026 * You should have received a copy of the GNU Library General Public
8027 * License along with this library; if not, write to the Free
8028 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
8031 #ifndef __GTK_DIAL_H__
8032 #define __GTK_DIAL_H__
8034 #include <gdk/gdk.h>
8035 #include <gtk/gtkadjustment.h>
8036 #include <gtk/gtkwidget.h>
8041 #endif /* __cplusplus */
8044 #define GTK_DIAL(obj) GTK_CHECK_CAST (obj, gtk_dial_get_type (), GtkDial)
8045 #define GTK_DIAL_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_dial_get_type (), GtkDialClass)
8046 #define GTK_IS_DIAL(obj) GTK_CHECK_TYPE (obj, gtk_dial_get_type ())
8049 typedef struct _GtkDial GtkDial;
8050 typedef struct _GtkDialClass GtkDialClass;
8056 /* update policy (GTK_UPDATE_[CONTINUOUS/DELAYED/DISCONTINUOUS]) */
8059 /* Button currently pressed or 0 if none */
8062 /* Dimensions of dial components */
8066 /* ID of update timer, or 0 if none */
8072 /* Old values from adjustment stored so we know when something changes */
8077 /* The adjustment object that stores the data for this dial */
8078 GtkAdjustment *adjustment;
8081 struct _GtkDialClass
8083 GtkWidgetClass parent_class;
8087 GtkWidget* gtk_dial_new (GtkAdjustment *adjustment);
8088 guint gtk_dial_get_type (void);
8089 GtkAdjustment* gtk_dial_get_adjustment (GtkDial *dial);
8090 void gtk_dial_set_update_policy (GtkDial *dial,
8091 GtkUpdateType policy);
8093 void gtk_dial_set_adjustment (GtkDial *dial,
8094 GtkAdjustment *adjustment);
8097 #endif /* __cplusplus */
8100 #endif /* __GTK_DIAL_H__ */
8103 Since there is quite a bit more going on in this widget, than the last
8104 one, we have more fields in the data structure, but otherwise things
8107 Next, after including header files, and declaring a few constants,
8108 we have some functions to provide information about the widget
8114 #include <gtk/gtkmain.h>
8115 #include <gtk/gtksignal.h>
8117 #include "gtkdial.h"
8119 #define SCROLL_DELAY_LENGTH 300
8120 #define DIAL_DEFAULT_SIZE 100
8122 /* Forward declararations */
8124 [ omitted to save space ]
8128 static GtkWidgetClass *parent_class = NULL;
8131 gtk_dial_get_type ()
8133 static guint dial_type = 0;
8137 GtkTypeInfo dial_info =
8141 sizeof (GtkDialClass),
8142 (GtkClassInitFunc) gtk_dial_class_init,
8143 (GtkObjectInitFunc) gtk_dial_init,
8144 (GtkArgSetFunc) NULL,
8145 (GtkArgGetFunc) NULL,
8148 dial_type = gtk_type_unique (gtk_widget_get_type (), &dial_info);
8155 gtk_dial_class_init (GtkDialClass *class)
8157 GtkObjectClass *object_class;
8158 GtkWidgetClass *widget_class;
8160 object_class = (GtkObjectClass*) class;
8161 widget_class = (GtkWidgetClass*) class;
8163 parent_class = gtk_type_class (gtk_widget_get_type ());
8165 object_class->destroy = gtk_dial_destroy;
8167 widget_class->realize = gtk_dial_realize;
8168 widget_class->expose_event = gtk_dial_expose;
8169 widget_class->size_request = gtk_dial_size_request;
8170 widget_class->size_allocate = gtk_dial_size_allocate;
8171 widget_class->button_press_event = gtk_dial_button_press;
8172 widget_class->button_release_event = gtk_dial_button_release;
8173 widget_class->motion_notify_event = gtk_dial_motion_notify;
8177 gtk_dial_init (GtkDial *dial)
8180 dial->policy = GTK_UPDATE_CONTINUOUS;
8183 dial->pointer_width = 0;
8185 dial->old_value = 0.0;
8186 dial->old_lower = 0.0;
8187 dial->old_upper = 0.0;
8188 dial->adjustment = NULL;
8192 gtk_dial_new (GtkAdjustment *adjustment)
8196 dial = gtk_type_new (gtk_dial_get_type ());
8199 adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
8201 gtk_dial_set_adjustment (dial, adjustment);
8203 return GTK_WIDGET (dial);
8207 gtk_dial_destroy (GtkObject *object)
8211 g_return_if_fail (object != NULL);
8212 g_return_if_fail (GTK_IS_DIAL (object));
8214 dial = GTK_DIAL (object);
8216 if (dial->adjustment)
8217 gtk_object_unref (GTK_OBJECT (dial->adjustment));
8219 if (GTK_OBJECT_CLASS (parent_class)->destroy)
8220 (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
8224 Note that this <tt/init()/ function does less than for the Tictactoe
8225 widget, since this is not a composite widget, and the <tt/new()/
8226 function does more, since it now has an argument. Also, note that when
8227 we store a pointer to the Adjustment object, we increment its
8228 reference count, (and correspondingly decrement when we no longer use
8229 it) so that GTK can keep track of when it can be safely destroyed.
8232 Also, there are a few function to manipulate the widget's options:
8236 gtk_dial_get_adjustment (GtkDial *dial)
8238 g_return_val_if_fail (dial != NULL, NULL);
8239 g_return_val_if_fail (GTK_IS_DIAL (dial), NULL);
8241 return dial->adjustment;
8245 gtk_dial_set_update_policy (GtkDial *dial,
8246 GtkUpdateType policy)
8248 g_return_if_fail (dial != NULL);
8249 g_return_if_fail (GTK_IS_DIAL (dial));
8251 dial->policy = policy;
8255 gtk_dial_set_adjustment (GtkDial *dial,
8256 GtkAdjustment *adjustment)
8258 g_return_if_fail (dial != NULL);
8259 g_return_if_fail (GTK_IS_DIAL (dial));
8261 if (dial->adjustment)
8263 gtk_signal_disconnect_by_data (GTK_OBJECT (dial->adjustment), (gpointer) dial);
8264 gtk_object_unref (GTK_OBJECT (dial->adjustment));
8267 dial->adjustment = adjustment;
8268 gtk_object_ref (GTK_OBJECT (dial->adjustment));
8270 gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
8271 (GtkSignalFunc) gtk_dial_adjustment_changed,
8273 gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
8274 (GtkSignalFunc) gtk_dial_adjustment_value_changed,
8277 dial->old_value = adjustment->value;
8278 dial->old_lower = adjustment->lower;
8279 dial->old_upper = adjustment->upper;
8281 gtk_dial_update (dial);
8285 <sect2> <tt/gtk_dial_realize()/
8288 Now we come to some new types of functions. First, we have a function
8289 that does the work of creating the X window. Notice that a mask is
8290 passed to the function <tt/gdk_window_new()/ which specifies which fields of
8291 the GdkWindowAttr structure actually have data in them (the remaining
8292 fields wll be given default values). Also worth noting is the way the
8293 event mask of the widget is created. We call
8294 <tt/gtk_widget_get_events()/ to retrieve the event mask that the user
8295 has specified for this widget (with <tt/gtk_widget_set_events()/, and
8296 add the events that we are interested in ourselves.
8299 After creating the window, we set its style and background, and put a
8300 pointer to the widget in the user data field of the GdkWindow. This
8301 last step allows GTK to dispatch events for this window to the correct
8306 gtk_dial_realize (GtkWidget *widget)
8309 GdkWindowAttr attributes;
8310 gint attributes_mask;
8312 g_return_if_fail (widget != NULL);
8313 g_return_if_fail (GTK_IS_DIAL (widget));
8315 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
8316 dial = GTK_DIAL (widget);
8318 attributes.x = widget->allocation.x;
8319 attributes.y = widget->allocation.y;
8320 attributes.width = widget->allocation.width;
8321 attributes.height = widget->allocation.height;
8322 attributes.wclass = GDK_INPUT_OUTPUT;
8323 attributes.window_type = GDK_WINDOW_CHILD;
8324 attributes.event_mask = gtk_widget_get_events (widget) |
8325 GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
8326 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
8327 GDK_POINTER_MOTION_HINT_MASK;
8328 attributes.visual = gtk_widget_get_visual (widget);
8329 attributes.colormap = gtk_widget_get_colormap (widget);
8331 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
8332 widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
8334 widget->style = gtk_style_attach (widget->style, widget->window);
8336 gdk_window_set_user_data (widget->window, widget);
8338 gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
8342 <sect2> Size negotiation
8345 Before the first time that the window containing a widget is
8346 displayed, and whenever the layout of the window changes, GTK asks
8347 each child widget for its desired size. This request is handled by the
8348 function, <tt/gtk_dial_size_request()/. Since our widget isn't a
8349 container widget, and has no real constraints on its size, we just
8350 return a reasonable default value.
8354 gtk_dial_size_request (GtkWidget *widget,
8355 GtkRequisition *requisition)
8357 requisition->width = DIAL_DEFAULT_SIZE;
8358 requisition->height = DIAL_DEFAULT_SIZE;
8363 After all the widgets have requested an ideal size, the layout of the
8364 window is computed and each child widget is notified of its actual
8365 size. Usually, this will at least as large as the requested size, but
8366 if for instance, the user has resized the window, it may occasionally
8367 be smaller than the requested size. The size notification is handled
8368 by the function <tt/gtk_dial_size_allocate()/. Notice that as well as
8369 computing the sizes of some component pieces for future use, this
8370 routine also does the grunt work of moving the widgets X window into
8371 the new position and size.
8375 gtk_dial_size_allocate (GtkWidget *widget,
8376 GtkAllocation *allocation)
8380 g_return_if_fail (widget != NULL);
8381 g_return_if_fail (GTK_IS_DIAL (widget));
8382 g_return_if_fail (allocation != NULL);
8384 widget->allocation = *allocation;
8385 if (GTK_WIDGET_REALIZED (widget))
8387 dial = GTK_DIAL (widget);
8389 gdk_window_move_resize (widget->window,
8390 allocation->x, allocation->y,
8391 allocation->width, allocation->height);
8393 dial->radius = MAX(allocation->width,allocation->height) * 0.45;
8394 dial->pointer_width = dial->radius / 5;
8399 <!-- ----------------------------------------------------------------- -->
8400 <sect2> <tt/gtk_dial_expose()/
8403 As mentioned above, all the drawing of this widget is done in the
8404 handler for expose events. There's not much to remark on here except
8405 the use of the function <tt/gtk_draw_polygon/ to draw the pointer with
8406 three dimensional shading according to the colors stored in the
8411 gtk_dial_expose (GtkWidget *widget,
8412 GdkEventExpose *event)
8422 g_return_val_if_fail (widget != NULL, FALSE);
8423 g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
8424 g_return_val_if_fail (event != NULL, FALSE);
8426 if (event->count > 0)
8429 dial = GTK_DIAL (widget);
8431 gdk_window_clear_area (widget->window,
8433 widget->allocation.width,
8434 widget->allocation.height);
8436 xc = widget->allocation.width/2;
8437 yc = widget->allocation.height/2;
8441 for (i=0; i<25; i++)
8443 theta = (i*M_PI/18. - M_PI/6.);
8447 tick_length = (i%6 == 0) ? dial->pointer_width : dial->pointer_width/2;
8449 gdk_draw_line (widget->window,
8450 widget->style->fg_gc[widget->state],
8451 xc + c*(dial->radius - tick_length),
8452 yc - s*(dial->radius - tick_length),
8453 xc + c*dial->radius,
8454 yc - s*dial->radius);
8459 s = sin(dial->angle);
8460 c = cos(dial->angle);
8463 points[0].x = xc + s*dial->pointer_width/2;
8464 points[0].y = yc + c*dial->pointer_width/2;
8465 points[1].x = xc + c*dial->radius;
8466 points[1].y = yc - s*dial->radius;
8467 points[2].x = xc - s*dial->pointer_width/2;
8468 points[2].y = yc - c*dial->pointer_width/2;
8470 gtk_draw_polygon (widget->style,
8481 <!-- ----------------------------------------------------------------- -->
8482 <sect2> Event handling
8486 The rest of the widget's code handles various types of events, and
8487 isn't too different from what would be found in many GTK
8488 applications. Two types of events can occur - either the user can
8489 click on the widget with the mouse and drag to move the pointer, or
8490 the value of the Adjustment object can change due to some external
8494 When the user clicks on the widget, we check to see if the click was
8495 appropriately near the pointer, and if so, store then button that the
8496 user clicked with in the <tt/button/ field of the widget
8497 structure, and grab all mouse events with a call to
8498 <tt/gtk_grab_add()/. Subsequent motion of the mouse causes the
8499 value of the control to be recomputed (by the function
8500 <tt/gtk_dial_update_mouse/). Depending on the policy that has been
8501 set, "value_changed" events are either generated instantly
8502 (<tt/GTK_UPDATE_CONTINUOUS/), after a delay in a timer added with
8503 <tt/gtk_timeout_add()/ (<tt/GTK_UPDATE_DELAYED/), or only when the
8504 button is released (<tt/GTK_UPDATE_DISCONTINUOUS/).
8508 gtk_dial_button_press (GtkWidget *widget,
8509 GdkEventButton *event)
8515 double d_perpendicular;
8517 g_return_val_if_fail (widget != NULL, FALSE);
8518 g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
8519 g_return_val_if_fail (event != NULL, FALSE);
8521 dial = GTK_DIAL (widget);
8523 /* Determine if button press was within pointer region - we
8524 do this by computing the parallel and perpendicular distance of
8525 the point where the mouse was pressed from the line passing through
8528 dx = event->x - widget->allocation.width / 2;
8529 dy = widget->allocation.height / 2 - event->y;
8531 s = sin(dial->angle);
8532 c = cos(dial->angle);
8534 d_parallel = s*dy + c*dx;
8535 d_perpendicular = fabs(s*dx - c*dy);
8537 if (!dial->button &&
8538 (d_perpendicular < dial->pointer_width/2) &&
8539 (d_parallel > - dial->pointer_width))
8541 gtk_grab_add (widget);
8543 dial->button = event->button;
8545 gtk_dial_update_mouse (dial, event->x, event->y);
8552 gtk_dial_button_release (GtkWidget *widget,
8553 GdkEventButton *event)
8557 g_return_val_if_fail (widget != NULL, FALSE);
8558 g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
8559 g_return_val_if_fail (event != NULL, FALSE);
8561 dial = GTK_DIAL (widget);
8563 if (dial->button == event->button)
8565 gtk_grab_remove (widget);
8569 if (dial->policy == GTK_UPDATE_DELAYED)
8570 gtk_timeout_remove (dial->timer);
8572 if ((dial->policy != GTK_UPDATE_CONTINUOUS) &&
8573 (dial->old_value != dial->adjustment->value))
8574 gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
8581 gtk_dial_motion_notify (GtkWidget *widget,
8582 GdkEventMotion *event)
8585 GdkModifierType mods;
8588 g_return_val_if_fail (widget != NULL, FALSE);
8589 g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
8590 g_return_val_if_fail (event != NULL, FALSE);
8592 dial = GTK_DIAL (widget);
8594 if (dial->button != 0)
8599 if (event->is_hint || (event->window != widget->window))
8600 gdk_window_get_pointer (widget->window, &x, &y, &mods);
8602 switch (dial->button)
8605 mask = GDK_BUTTON1_MASK;
8608 mask = GDK_BUTTON2_MASK;
8611 mask = GDK_BUTTON3_MASK;
8619 gtk_dial_update_mouse (dial, x,y);
8626 gtk_dial_timer (GtkDial *dial)
8628 g_return_val_if_fail (dial != NULL, FALSE);
8629 g_return_val_if_fail (GTK_IS_DIAL (dial), FALSE);
8631 if (dial->policy == GTK_UPDATE_DELAYED)
8632 gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
8638 gtk_dial_update_mouse (GtkDial *dial, gint x, gint y)
8643 g_return_if_fail (dial != NULL);
8644 g_return_if_fail (GTK_IS_DIAL (dial));
8646 xc = GTK_WIDGET(dial)->allocation.width / 2;
8647 yc = GTK_WIDGET(dial)->allocation.height / 2;
8649 old_value = dial->adjustment->value;
8650 dial->angle = atan2(yc-y, x-xc);
8652 if (dial->angle < -M_PI/2.)
8653 dial->angle += 2*M_PI;
8655 if (dial->angle < -M_PI/6)
8656 dial->angle = -M_PI/6;
8658 if (dial->angle > 7.*M_PI/6.)
8659 dial->angle = 7.*M_PI/6.;
8661 dial->adjustment->value = dial->adjustment->lower + (7.*M_PI/6 - dial->angle) *
8662 (dial->adjustment->upper - dial->adjustment->lower) / (4.*M_PI/3.);
8664 if (dial->adjustment->value != old_value)
8666 if (dial->policy == GTK_UPDATE_CONTINUOUS)
8668 gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
8672 gtk_widget_draw (GTK_WIDGET(dial), NULL);
8674 if (dial->policy == GTK_UPDATE_DELAYED)
8677 gtk_timeout_remove (dial->timer);
8679 dial->timer = gtk_timeout_add (SCROLL_DELAY_LENGTH,
8680 (GtkFunction) gtk_dial_timer,
8689 Changes to the Adjustment by external means are communicated to our
8690 widget by the ``changed'' and ``value_changed'' signals. The handlers
8691 for these functions call <tt/gtk_dial_update()/ to validate the
8692 arguments, compute the new pointer angle, and redraw the widget (by
8693 calling <tt/gtk_widget_draw()/).
8697 gtk_dial_update (GtkDial *dial)
8701 g_return_if_fail (dial != NULL);
8702 g_return_if_fail (GTK_IS_DIAL (dial));
8704 new_value = dial->adjustment->value;
8706 if (new_value < dial->adjustment->lower)
8707 new_value = dial->adjustment->lower;
8709 if (new_value > dial->adjustment->upper)
8710 new_value = dial->adjustment->upper;
8712 if (new_value != dial->adjustment->value)
8714 dial->adjustment->value = new_value;
8715 gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
8718 dial->angle = 7.*M_PI/6. - (new_value - dial->adjustment->lower) * 4.*M_PI/3. /
8719 (dial->adjustment->upper - dial->adjustment->lower);
8721 gtk_widget_draw (GTK_WIDGET(dial), NULL);
8725 gtk_dial_adjustment_changed (GtkAdjustment *adjustment,
8730 g_return_if_fail (adjustment != NULL);
8731 g_return_if_fail (data != NULL);
8733 dial = GTK_DIAL (data);
8735 if ((dial->old_value != adjustment->value) ||
8736 (dial->old_lower != adjustment->lower) ||
8737 (dial->old_upper != adjustment->upper))
8739 gtk_dial_update (dial);
8741 dial->old_value = adjustment->value;
8742 dial->old_lower = adjustment->lower;
8743 dial->old_upper = adjustment->upper;
8748 gtk_dial_adjustment_value_changed (GtkAdjustment *adjustment,
8753 g_return_if_fail (adjustment != NULL);
8754 g_return_if_fail (data != NULL);
8756 dial = GTK_DIAL (data);
8758 if (dial->old_value != adjustment->value)
8760 gtk_dial_update (dial);
8762 dial->old_value = adjustment->value;
8767 <!-- ----------------------------------------------------------------- -->
8768 <sect2> Possible Enhancements
8771 The Dial widget as we've described it so far runs about 670 lines of
8772 code. Although that might sound like a fair bit, we've really
8773 accomplished quite a bit with that much code, especially since much of
8774 that length is headers and boilerplate. However, there are quite a few
8775 more enhancements that could be made to this widget:
8778 <item> If you try this widget out, you'll find that there is some
8779 flashing as the pointer is dragged around. This is because the entire
8780 widget is erased every time the pointer is moved before being
8781 redrawn. Often, the best way to handle this problem is to draw to an
8782 offscreen pixmap, then copy the final results onto the screen in one
8783 step. (The ProgressBar widget draws itself in this fashion.)
8785 <item> The user should be able to use the up and down arrow keys to
8786 increase and decrease the value.
8788 <item> It would be nice if the widget had buttons to increase and
8789 decrease the value in small or large steps. Although it would be
8790 possible to use embedded Button widgets for this, we would also like
8791 the buttons to auto-repeat when held down, as the arrows on a
8792 scrollbar do. Most of the code to implement this type of behavior can
8793 be found in the GtkRange widget.
8795 <item> The Dial widget could be made into a container widget with a
8796 single child widget positioned at the bottom between the buttons
8797 mentioned above. The user could then add their choice of a label or
8798 entry widget to display the current value of the dial.
8802 <!-- ----------------------------------------------------------------- -->
8803 <sect1> Learning More
8806 Only a small part of the many details involved in creating widgets
8807 could be described above. If you want to write your own widgets, the
8808 best source of examples is the GTK source itself. Ask yourself some
8809 questions about the widget you want to write: is it a Container
8810 widget? does it have its own window? is it a modification of an
8811 existing widget? Then find a similar widget, and start making changes.
8814 <!-- ***************************************************************** -->
8815 <sect>Scribble, A Simple Example Drawing Program
8816 <!-- ***************************************************************** -->
8818 <!-- ----------------------------------------------------------------- -->
8822 In this section, we will build a simple drawing program. In the
8823 process, we will examine how to handle mouse events, how to draw in a
8824 window, and how to do drawing better by using a backing pixmap. After
8825 creating the simple drawing program, we will extend it by adding
8826 support for XInput devices, such as drawing tablets. GTK provides
8827 support routines which makes getting extended information, such as
8828 pressure and tilt, from such devices quite easy.
8830 <!-- ----------------------------------------------------------------- -->
8831 <sect1> Event Handling
8834 The GTK signals we have already discussed are for high-level actions,
8835 such as a menu item being selected. However, sometimes it is useful to
8836 learn about lower-level occurrences, such as the mouse being moved, or
8837 a key being pressed. There are also GTK signals corresponding to these
8838 low-level <em>events</em>. The handlers for these signals have an
8839 extra parameter which is a pointer to a structure containing
8840 information about the event. For instance, motion events handlers are
8841 passed a pointer to a GdkEventMotion structure which looks (in part)
8845 struct _GdkEventMotion
8858 <tt/type/ will be set to the event type, in this case
8859 <tt/GDK_MOTION_NOTIFY/, window is the window in which the event
8860 occured. <tt/x/ and <tt/y/ give the coordinates of the event,
8861 and <tt/state/ specifies the modifier state when the event
8862 occurred (that is, it specifies which modifier keys and mouse buttons
8863 were pressed.) It is the bitwise OR of some of the following:
8882 As for other signals, to determine what happens when an event occurs
8883 we call <tt>gtk_signal_connect()</tt>. But we also need let GTK
8884 know which events we want to be notified about. To do this, we call
8888 void gtk_widget_set_events (GtkWidget *widget,
8892 The second field specifies the events we are interested in. It
8893 is the bitwise OR of constants that specify different types
8894 of events. For future reference the event types are:
8898 GDK_POINTER_MOTION_MASK
8899 GDK_POINTER_MOTION_HINT_MASK
8900 GDK_BUTTON_MOTION_MASK
8901 GDK_BUTTON1_MOTION_MASK
8902 GDK_BUTTON2_MOTION_MASK
8903 GDK_BUTTON3_MOTION_MASK
8904 GDK_BUTTON_PRESS_MASK
8905 GDK_BUTTON_RELEASE_MASK
8907 GDK_KEY_RELEASE_MASK
8908 GDK_ENTER_NOTIFY_MASK
8909 GDK_LEAVE_NOTIFY_MASK
8910 GDK_FOCUS_CHANGE_MASK
8912 GDK_PROPERTY_CHANGE_MASK
8913 GDK_PROXIMITY_IN_MASK
8914 GDK_PROXIMITY_OUT_MASK
8917 There are a few subtle points that have to be observed when calling
8918 <tt/gtk_widget_set_events()/. First, it must be called before the X window
8919 for a GTK widget is created. In practical terms, this means you
8920 should call it immediately after creating the widget. Second, the
8921 widget must have an associated X window. For efficiency, many widget
8922 types do not have their own window, but draw in their parent's window.
8945 To capture events for these widgets, you need to use an EventBox
8946 widget. See the section on
8947 <ref id="sec_The_EventBox_Widget" name="The EventBox Widget"> for
8951 For our drawing program, we want to know when the mouse button is
8952 pressed and when the mouse is moved, so we specify
8953 <tt/GDK_POINTER_MOTION_MASK/ and <tt/GDK_BUTTON_PRESS_MASK/. We also
8954 want to know when we need to redraw our window, so we specify
8955 <tt/GDK_EXPOSURE_MASK/. Although we want to be notified via a
8956 Configure event when our window size changes, we don't have to specify
8957 the corresponding <tt/GDK_STRUCTURE_MASK/ flag, because it is
8958 automatically specified for all windows.
8961 It turns out, however, that there is a problem with just specifying
8962 <tt/GDK_POINTER_MOTION_MASK/. This will cause the server to add a new
8963 motion event to the event queue every time the user moves the mouse.
8964 Imagine that it takes us 0.1 seconds to handle a motion event, but the
8965 X server queues a new motion event every 0.05 seconds. We will soon
8966 get way behind the users drawing. If the user draws for 5 seconds,
8967 it will take us another 5 seconds to catch up after they release
8968 the mouse button! What we would like is to only get one motion
8969 event for each event we process. The way to do this is to
8970 specify <tt/GDK_POINTER_MOTION_HINT_MASK/.
8973 When we specify <tt/GDK_POINTER_MOTION_HINT_MASK/, the server sends
8974 us a motion event the first time the pointer moves after entering
8975 our window, or after a button press or release event. Subsequent
8976 motion events will be suppressed until we explicitely ask for
8977 the position of the pointer using the function:
8980 GdkWindow* gdk_window_get_pointer (GdkWindow *window,
8983 GdkModifierType *mask);
8986 (There is another function, <tt>gtk_widget_get_pointer()</tt> which
8987 has a simpler interface, but turns out not to be very useful, since
8988 it only retrieves the position of the mouse, not whether the buttons
8992 The code to set the events for our window then looks like:
8995 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
8996 (GtkSignalFunc) expose_event, NULL);
8997 gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
8998 (GtkSignalFunc) configure_event, NULL);
8999 gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
9000 (GtkSignalFunc) motion_notify_event, NULL);
9001 gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
9002 (GtkSignalFunc) button_press_event, NULL);
9004 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
9005 | GDK_LEAVE_NOTIFY_MASK
9006 | GDK_BUTTON_PRESS_MASK
9007 | GDK_POINTER_MOTION_MASK
9008 | GDK_POINTER_MOTION_HINT_MASK);
9011 We'll save the "expose_event" and "configure_event" handlers for
9012 later. The "motion_notify_event" and "button_press_event" handlers
9017 button_press_event (GtkWidget *widget, GdkEventButton *event)
9019 if (event->button == 1 && pixmap != NULL)
9020 draw_brush (widget, event->x, event->y);
9026 motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
9029 GdkModifierType state;
9032 gdk_window_get_pointer (event->window, &x, &y, &state);
9037 state = event->state;
9040 if (state & GDK_BUTTON1_MASK && pixmap != NULL)
9041 draw_brush (widget, x, y);
9047 <!-- ----------------------------------------------------------------- -->
9048 <sect1> The DrawingArea Widget, And Drawing
9051 We know turn to the process of drawing on the screen. The
9052 widget we use for this is the DrawingArea widget. A drawing area
9053 widget is essentially an X window and nothing more. It is a blank
9054 canvas in which we can draw whatever we like. A drawing area
9055 is created using the call:
9058 GtkWidget* gtk_drawing_area_new (void);
9061 A default size for the widget can be specified by calling:
9064 void gtk_drawing_area_size (GtkDrawingArea *darea,
9069 This default size can be overriden, as is true for all widgets,
9070 by calling <tt>gtk_widget_set_usize()</tt>, and that, in turn, can
9071 be overridden if the user manually resizes the the window containing
9075 It should be noted that when we create a DrawingArea widget, we are,
9076 <em>completely</em> responsible for drawing the contents. If our
9077 window is obscured then uncovered, we get an exposure event and must
9078 redraw what was previously hidden.
9081 Having to remember everything that was drawn on the screen so we
9082 can properly redraw it can, to say the least, be a nuisance. In
9083 addition, it can be visually distracting if portions of the
9084 window are cleared, then redrawn step by step. The solution to
9085 this problem is to use an offscreen <em>backing pixmap</em>.
9086 Instead of drawing directly to the screen, we draw to an image
9087 stored in server memory but not displayed, then when the image
9088 changes or new portions of the image are displayed, we copy the
9089 relevant portions onto the screen.
9092 To create an offscreen pixmap, we call the function:
9095 GdkPixmap* gdk_pixmap_new (GdkWindow *window,
9101 The <tt>window</tt> parameter specifies a GDK window that this pixmap
9102 takes some of its properties from. <tt>width</tt> and <tt>height</tt>
9103 specify the size of the pixmap. <tt>depth</tt> specifies the <em>color
9104 depth</em>, that is the number of bits per pixel, for the new window.
9105 If the depth is specified as <tt>-1</tt>, it will match the depth
9109 We create the pixmap in our "configure_event" handler. This event
9110 is generated whenever the window changes size, including when it
9111 is originally created.
9114 /* Backing pixmap for drawing area */
9115 static GdkPixmap *pixmap = NULL;
9117 /* Create a new backing pixmap of the appropriate size */
9119 configure_event (GtkWidget *widget, GdkEventConfigure *event)
9123 gdk_pixmap_destroy(pixmap);
9125 pixmap = gdk_pixmap_new(widget->window,
9126 widget->allocation.width,
9127 widget->allocation.height,
9129 gdk_draw_rectangle (pixmap,
9130 widget->style->white_gc,
9133 widget->allocation.width,
9134 widget->allocation.height);
9140 The call to <tt>gdk_draw_rectangle()</tt> clears the pixmap
9141 initially to white. We'll say more about that in a moment.
9144 Our exposure event handler then simply copies the relevant portion
9145 of the pixmap onto the screen (we determine the area we need
9146 to redraw by using the event->area field of the exposure event):
9149 /* Refill the screen from the backing pixmap */
9151 expose_event (GtkWidget *widget, GdkEventExpose *event)
9153 gdk_draw_pixmap(widget->window,
9154 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
9156 event->area.x, event->area.y,
9157 event->area.x, event->area.y,
9158 event->area.width, event->area.height);
9164 We've now seen how to keep the screen up to date with our pixmap, but
9165 how do we actually draw interesting stuff on our pixmap? There are a
9166 large number of calls in GTK's GDK library for drawing on
9167 <em>drawables</em>. A drawable is simply something that can be drawn
9168 upon. It can be a window, a pixmap, or a bitmap (a black and white
9169 image). We've already seen two such calls above,
9170 <tt>gdk_draw_rectangle()</tt> and <tt>gdk_draw_pixmap()</tt>. The
9175 gdk_draw_rectangle ()
9184 gdk_draw_segments ()
9187 See the reference documentation or the header file
9188 <tt><gdk/gdk.h></tt> for further details on these functions.
9189 These functions all share the same first two arguments. The first
9190 argument is the drawable to draw upon, the second argument is a
9191 <em>graphics context</em> (GC).
9194 A graphics context encapsulates information about things such as
9195 foreground and background color and line width. GDK has a full set of
9196 functions for creating and modifying graphics contexts, but to keep
9197 things simple we'll just use predefined graphics contexts. Each widget
9198 has an associated style. (Which can be modified in a gtkrc file, see
9199 the section GTK's rc file.) This, among other things, stores a number
9200 of graphics contexts. Some examples of accessing these graphics
9204 widget->style->white_gc
9205 widget->style->black_gc
9206 widget->style->fg_gc[GTK_STATE_NORMAL]
9207 widget->style->bg_gc[GTK_WIDGET_STATE(widget)]
9210 The fields <tt>fg_gc</tt>, <tt>bg_gc</tt>, <tt>dark_gc</tt>, and
9211 <tt>light_gc</tt> are indexed by a parameter of type
9212 <tt>GtkStateType</tt> which can take on the values:
9219 GTK_STATE_INSENSITIVE
9222 For instance, the for <tt/GTK_STATE_SELECTED/ the default foreground
9223 color is white and the default background color, dark blue.
9226 Our function <tt>draw_brush()</tt>, which does the actual drawing
9227 on the screen, is then:
9230 /* Draw a rectangle on the screen */
9232 draw_brush (GtkWidget *widget, gdouble x, gdouble y)
9234 GdkRectangle update_rect;
9236 update_rect.x = x - 5;
9237 update_rect.y = y - 5;
9238 update_rect.width = 10;
9239 update_rect.height = 10;
9240 gdk_draw_rectangle (pixmap,
9241 widget->style->black_gc,
9243 update_rect.x, update_rect.y,
9244 update_rect.width, update_rect.height);
9245 gtk_widget_draw (widget, &update_rect);
9249 After we draw the rectangle representing the brush onto the pixmap,
9250 we call the function:
9253 void gtk_widget_draw (GtkWidget *widget,
9254 GdkRectangle *area);
9257 which notifies X that the area given by the <tt>area</tt> parameter
9258 needs to be updated. X will eventually generate an expose event
9259 (possibly combining the areas passed in several calls to
9260 <tt>gtk_widget_draw()</tt>) which will cause our expose event handler
9261 to copy the relevant portions to the screen.
9264 We have now covered the entire drawing program except for a few
9265 mundane details like creating the main window. The complete
9266 source code is available from the location from which you got
9267 this tutorial, or from:
9269 <htmlurl url="http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial"
9270 name="http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial">
9273 <!-- ----------------------------------------------------------------- -->
9274 <sect1> Adding XInput support
9278 It is now possible to buy quite inexpensive input devices such
9279 as drawing tablets, which allow drawing with a much greater
9280 ease of artistic expression than does a mouse. The simplest way
9281 to use such devices is simply as a replacement for the mouse,
9282 but that misses out many of the advantages of these devices,
9286 <item> Pressure sensitivity
9287 <item> Tilt reporting
9288 <item> Sub-pixel positioning
9289 <item> Multiple inputs (for example, a stylus with a point and eraser)
9292 For information about the XInput extension, see the <htmlurl
9293 url="http://www.msc.cornell.edu/~otaylor/xinput/XInput-HOWTO.html"
9294 name="XInput-HOWTO">.
9297 If we examine the full definition of, for example, the GdkEventMotion
9298 structure, we see that it has fields to support extended device
9302 struct _GdkEventMotion
9314 GdkInputSource source;
9319 <tt/pressure/ gives the pressure as a floating point number between
9320 0 and 1. <tt/xtilt/ and <tt/ytilt/ can take on values between
9321 -1 and 1, corresponding to the degree of tilt in each direction.
9322 <tt/source/ and <tt/deviceid/ specify the device for which the
9323 event occurred in two different ways. <tt/source/ gives some simple
9324 information about the type of device. It can take the enumeration
9334 <tt/deviceid/ specifies a unique numeric ID for the device. This can
9335 be used to find out further information about the device using the
9336 <tt/gdk_input_list_devices()/ call (see below). The special value
9337 <tt/GDK_CORE_POINTER/ is used for the core pointer device. (Usually
9340 <sect2> Enabling extended device information
9343 To let GTK know about our interest in the extended device information,
9344 we merely have to add a single line to our program:
9347 gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_CURSOR);
9350 By giving the value <tt/GDK_EXTENSION_EVENTS_CURSOR/ we say that
9351 we are interested in extension events, but only if we don't have
9352 to draw our own cursor. See the section <ref
9353 id="sec_Further_Sophistications" name="Further Sophistications"> below
9354 for more information about drawing the cursor. We could also
9355 give the values <tt/GDK_EXTENSION_EVENTS_ALL/ if we were willing
9356 to draw our own cursor, or <tt/GDK_EXTENSION_EVENTS_NONE/ to revert
9357 back to the default condition.
9360 This is not completely the end of the story however. By default,
9361 no extension devices are enabled. We need a mechanism to allow
9362 users to enable and configure their extension devices. GTK provides
9363 the InputDialog widget to automate this process. The following
9364 procedure manages an InputDialog widget. It creates the dialog if
9365 it isn't present, and raises it to the top otherwise.
9369 input_dialog_destroy (GtkWidget *w, gpointer data)
9371 *((GtkWidget **)data) = NULL;
9375 create_input_dialog ()
9377 static GtkWidget *inputd = NULL;
9381 inputd = gtk_input_dialog_new();
9383 gtk_signal_connect (GTK_OBJECT(inputd), "destroy",
9384 (GtkSignalFunc)input_dialog_destroy, &inputd);
9385 gtk_signal_connect_object (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
9387 (GtkSignalFunc)gtk_widget_hide,
9388 GTK_OBJECT(inputd));
9389 gtk_widget_hide ( GTK_INPUT_DIALOG(inputd)->save_button);
9391 gtk_widget_show (inputd);
9395 if (!GTK_WIDGET_MAPPED(inputd))
9396 gtk_widget_show(inputd);
9398 gdk_window_raise(inputd->window);
9403 (You might want to take note of the way we handle this dialog. By
9404 connecting to the "destroy" signal, we make sure that we don't keep a
9405 pointer to dialog around after it is destroyed - that could lead to a
9409 The InputDialog has two buttons "Close" and "Save", which by default
9410 have no actions assigned to them. In the above function we make
9411 "Close" hide the dialog, hide the "Save" button, since we don't
9412 implement saving of XInput options in this program.
9414 <sect2> Using extended device information
9417 Once we've enabled the device, we can just use the extended
9418 device information in the extra fields of the event structures.
9419 In fact, it is always safe to use this information since these
9420 fields will have reasonable default values even when extended
9421 events are not enabled.
9424 Once change we do have to make is to call
9425 <tt/gdk_input_window_get_pointer()/ instead of
9426 <tt/gdk_window_get_pointer/. This is necessary because
9427 <tt/gdk_window_get_pointer/ doesn't return the extended device
9431 void gdk_input_window_get_pointer (GdkWindow *window,
9438 GdkModifierType *mask);
9441 When calling this function, we need to specify the device ID as
9442 well as the window. Usually, we'll get the device ID from the
9443 <tt/deviceid/ field of an event structure. Again, this function
9444 will return reasonable values when extension events are not
9445 enabled. (In this case, <tt/event->deviceid/ will have the value
9446 <tt/GDK_CORE_POINTER/).
9448 So the basic structure of our button-press and motion event handlers,
9449 doesn't change much - we just need to add code to deal with the
9450 extended information.
9454 button_press_event (GtkWidget *widget, GdkEventButton *event)
9456 print_button_press (event->deviceid);
9458 if (event->button == 1 && pixmap != NULL)
9459 draw_brush (widget, event->source, event->x, event->y, event->pressure);
9465 motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
9469 GdkModifierType state;
9472 gdk_input_window_get_pointer (event->window, event->deviceid,
9473 &x, &y, &pressure, NULL, NULL, &state);
9478 pressure = event->pressure;
9479 state = event->state;
9482 if (state & GDK_BUTTON1_MASK && pixmap != NULL)
9483 draw_brush (widget, event->source, x, y, pressure);
9489 We also need to do something with the new information. Our new
9490 <tt/draw_brush()/ function draws with a different color for
9491 each <tt/event->source/ and changes the brush size depending
9495 /* Draw a rectangle on the screen, size depending on pressure,
9496 and color on the type of device */
9498 draw_brush (GtkWidget *widget, GdkInputSource source,
9499 gdouble x, gdouble y, gdouble pressure)
9502 GdkRectangle update_rect;
9506 case GDK_SOURCE_MOUSE:
9507 gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)];
9509 case GDK_SOURCE_PEN:
9510 gc = widget->style->black_gc;
9512 case GDK_SOURCE_ERASER:
9513 gc = widget->style->white_gc;
9516 gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)];
9519 update_rect.x = x - 10 * pressure;
9520 update_rect.y = y - 10 * pressure;
9521 update_rect.width = 20 * pressure;
9522 update_rect.height = 20 * pressure;
9523 gdk_draw_rectangle (pixmap, gc, TRUE,
9524 update_rect.x, update_rect.y,
9525 update_rect.width, update_rect.height);
9526 gtk_widget_draw (widget, &update_rect);
9530 <sect2> Finding out more about a device
9533 As an example of how to find out more about a device, our program
9534 will print the name of the device that generates each button
9535 press. To find out the name of a device, we call the function:
9538 GList *gdk_input_list_devices (void);
9541 which returns a GList (a linked list type from the glib library)
9542 of GdkDeviceInfo structures. The GdkDeviceInfo strucure is defined
9546 struct _GdkDeviceInfo
9550 GdkInputSource source;
9560 Most of these fields are configuration information that you
9561 can ignore unless you are implemented XInput configuration
9562 saving. The we are interested in here is <tt/name/ which is
9563 simply the name that X assigns to the device. The other field
9564 that isn't configuration information is <tt/has_cursor/. If
9565 <tt/has_cursor/ is false, then we we need to draw our own
9566 cursor. But since we've specified <tt/GDK_EXTENSION_EVENTS_CURSOR/,
9567 we don't have to worry about this.
9570 Our <tt/print_button_press()/ function simply iterates through
9571 the returned list until it finds a match, then prints out
9572 the name of the device.
9576 print_button_press (guint32 deviceid)
9580 /* gdk_input_list_devices returns an internal list, so we shouldn't
9581 free it afterwards */
9582 tmp_list = gdk_input_list_devices();
9586 GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;
9588 if (info->deviceid == deviceid)
9590 printf("Button press on device '%s'\n", info->name);
9594 tmp_list = tmp_list->next;
9599 That completes the changes to ``XInputize'' our program. As with
9600 the first version, the complete source is available at the location
9601 from which you got this tutorial, or from:
9603 <htmlurl url="http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial"
9604 name="http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial">
9607 <sect2> Further sophistications <label id="sec_Further_Sophistications">
9610 Although our program now supports XInput quite well, it lacks some
9611 features we would want in a full-featured application. First, the user
9612 probably doesn't want to have to configure their device each time they
9613 run the program, so we should allow them to save the device
9614 configuration. This is done by iterating through the return of
9615 <tt/gdk_input_list_devices()/ and writing out the configuration to a
9619 To restore the state next time the program is run, GDK provides
9620 functions to change device configuration:
9623 gdk_input_set_extension_events()
9624 gdk_input_set_source()
9625 gdk_input_set_mode()
9626 gdk_input_set_axes()
9630 (The list returned from <tt/gdk_input_list_devices()/ should not be
9631 modified directly.) An example of doing this can be found in the
9632 drawing program gsumi. (Available from <htmlurl
9633 url="http://www.msc.cornell.edu/~otaylor/gsumi/"
9634 name="http://www.msc.cornell.edu/~otaylor/gsumi/">) Eventually, it
9635 would be nice to have a standard way of doing this for all
9636 applications. This probably belongs at a slightly higher level than
9637 GTK, perhaps in the GNOME library.
9640 Another major ommission that we have mentioned above is the lack of
9641 cursor drawing. Platforms other than XFree86 currently do not allow
9642 simultaneously using a device as both the core pointer and directly by
9643 an application. See the <url
9644 url="http://www.msc.cornell.edu/~otaylor/xinput/XInput-HOWTO.html"
9645 name="XInput-HOWTO"> for more information about this. This means that
9646 applications that want to support the widest audience need to draw
9650 An application that draws it's own cursor needs to do two things:
9651 determine if the current device needs a cursor drawn or not, and
9652 determine if the current device is in proximity. (If the current
9653 device is a drawing tablet, it's a nice touch to make the cursor
9654 disappear when the stylus is lifted from the tablet. When the
9655 device is touching the stylus, that is called "in proximity.")
9656 The first is done by searching the device list, as we did
9657 to find out the device name. The second is achieved by selecting
9658 "proximity_out" events. An example of drawing one's own cursor is
9659 found in the 'testinput' program found in the GTK distribution.
9661 <!-- ***************************************************************** -->
9662 <sect>Tips For Writing GTK Applications
9663 <!-- ***************************************************************** -->
9666 This section is simply a gathering of wisdom, general style guidelines and hints to
9667 creating good GTK applications. It is totally useless right now cause it's
9668 only a topic sentence :)
9670 Use GNU autoconf and automake! They are your friends :) I am planning to
9671 make a quick intro on them here.
9673 <!-- ***************************************************************** -->
9675 <!-- ***************************************************************** -->
9678 This document, like so much other great software out there, was created for
9679 free by volunteers. If you are at all knowledgeable about any aspect of GTK
9680 that does not already have documentation, please consider contributing to
9683 If you do decide to contribute, please mail your text to Tony Gale,
9684 <tt><htmlurl url="mailto:gale@gtk.org"
9685 name="gale@gtk.org"></tt>. Also, be aware that the entirety of this
9686 document is free, and any addition by yourself must also be free. That is,
9687 people may use any portion of your examples in their programs, and copies
9688 of this document may be distributed at will etc.
9692 <!-- ***************************************************************** -->
9694 <!-- ***************************************************************** -->
9696 I would like to thank the following for their contributions to this text.
9699 <item>Bawer Dagdeviren, <tt><htmlurl url="mailto:chamele0n@geocities.com"
9700 name="chamele0n@geocities.com"></tt> for the menus tutorial.
9702 <item>Raph Levien, <tt><htmlurl url="mailto:raph@acm.org"
9703 name="raph@acm.org"></tt>
9704 for hello world ala GTK, widget packing, and general all around wisdom.
9705 He's also generously donated a home for this tutorial.
9707 <item>Peter Mattis, <tt><htmlurl url="mailto:petm@xcf.berkeley.edu"
9708 name="petm@xcf.berkeley.edu"></tt> for the simplest GTK program..
9709 and the ability to make it :)
9711 <item>Werner Koch <tt><htmlurl url="mailto:werner.koch@guug.de"
9712 name="werner.koch@guug.de"></tt> for converting the original plain text to
9713 SGML, and the widget class hierarchy.
9715 <item>Mark Crichton <tt><htmlurl url="mailto:crichton@expert.cc.purdue.edu"
9716 name="crichton@expert.cc.purdue.edu"></tt> for the menu factory code, and
9717 the table packing tutorial.
9719 <item>Owen Taylor <tt><htmlurl url="mailto:owt1@cornell.edu"
9720 name="owt1@cornell.edu"></tt> for the EventBox widget section (and
9721 the patch to the distro). He's also responsible for the selections code and
9722 tutorial, as well as the sections on writing your own GTK widgets, and the
9723 example application. Thanks a lot Owen for all you help!
9725 <item>Mark VanderBoom <tt><htmlurl url="mailto:mvboom42@calvin.edu"
9726 name="mvboom42@calvin.edu"></tt> for his wonderful work on the Notebook,
9727 Progress Bar, Dialogs, and File selection widgets. Thanks a lot Mark!
9728 You've been a great help.
9730 <item>Tim Janik <tt><htmlurl url="mailto:timj@psynet.net"
9731 name="timj@psynet.net"></tt> for his great job on the Lists Widget.
9734 <item>Rajat Datta <tt><htmlurl url="mailto:rajat@ix.netcom.com"
9735 name="rajat@ix.netcom.com"</tt> for the excellent job on the Pixmap tutorial.
9737 <item>Michael K. Johnson <tt><htmlurl url="mailto:johnsonm@redhat.com"
9738 name="johnsonm@redhat.com"></tt> for info and code for popup menus.
9742 And to all of you who commented and helped refine this document.
9746 <!-- ***************************************************************** -->
9747 <sect> Tutorial Copyright and Permissions Notice
9748 <!-- ***************************************************************** -->
9751 The GTK Tutorial is Copyright (C) 1997 Ian Main.
9753 Copyright (C) 1998 Tony Gale.
9755 Permission is granted to make and distribute verbatim copies of this
9756 manual provided the copyright notice and this permission notice are
9757 preserved on all copies.
9758 <P>Permission is granted to copy and distribute modified versions of
9759 this document under the conditions for verbatim copying, provided that
9760 this copyright notice is included exactly as in the original,
9761 and that the entire resulting derived work is distributed under
9762 the terms of a permission notice identical to this one.
9763 <P>Permission is granted to copy and distribute translations of this
9764 document into another language, under the above conditions for modified
9766 <P>If you are intending to incorporate this document into a published
9767 work, please contact the maintainer, and we will make an effort
9768 to ensure that you have the most up to date information available.
9769 <P>There is no guarentee that this document lives up to its intended
9770 purpose. This is simply provided as a free resource. As such,
9771 the authors and maintainers of the information provided within can
9772 not make any guarentee that the information is even accurate.