Next Previous Contents

## 19. Managing Selections

## 19.1 Overview

One type of interprocess communication supported by X and GTK is selections. A selection identifies a chunk of data, for instance, a portion of text, selected by the user in some fashion, for instance, by dragging with the mouse. Only one application on a display (the owner) can own a particular selection at one time, so when a selection is claimed by one application, the previous owner must indicate to the user that selection has been relinquished. Other applications can request the contents of a selection in different forms, called targets. There can be any number of selections, but most X applications only handle one, the primary selection.

In most cases, it isn't necessary for a GTK application to deal with selections itself. The standard widgets, such as the Entry widget, already have the capability to claim the selection when appropriate (e.g., when the user drags over text), and to retrieve the contents of the selection owned by another widget or another application (e.g., when the user clicks the second mouse button). However, there may be cases in which you want to give other widgets the ability to supply the selection, or you wish to retrieve targets not supported by default.

A fundamental concept needed to understand selection handling is that of the atom. An atom is an integer that uniquely identifies a string (on a certain display). Certain atoms are predefined by the X server, and in some cases there are constants in `gtk.h` corresponding to these atoms. For instance the constant `GDK_PRIMARY_SELECTION` corresponds to the string "PRIMARY". In other cases, you should use the functions `gdk_atom_intern()`, to get the atom corresponding to a string, and `gdk_atom_name()`, to get the name of an atom. Both selections and targets are identified by atoms.

## 19.2 Retrieving the selection

Retrieving the selection is an asynchronous process. To start the process, you call:

> `

>     gint gtk_selection_convert( GtkWidget *widget,
>                                 GdkAtom    selection,
>                                 GdkAtom    target,
>                                 guint32    time );

> `

This converts the selection into the form specified by `target`. If at all possible, the time field should be the time from the event that triggered the selection. This helps make sure that events occur in the order that the user requested them. However, if it is not available (for instance, if the conversion was triggered by a "clicked" signal), then you can use the constant `GDK_CURRENT_TIME`.

When the selection owner responds to the request, a "selection_received" signal is sent to your application. The handler for this signal receives a pointer to a `GtkSelectionData` structure, which is defined as:

> `

>     struct _GtkSelectionData
>     {
>       GdkAtom selection;
>       GdkAtom target;
>       GdkAtom type;
>       gint    format;
>       guchar *data;
>       gint    length;
>     };

> `

`selection` and `target` are the values you gave in your `gtk_selection_convert()` call. `type` is an atom that identifies the type of data returned by the selection owner. Some possible values are "STRING", a string of latin-1 characters, "ATOM", a series of atoms, "INTEGER", an integer, etc. Most targets can only return one type. `format` gives the length of the units (for instance characters) in bits. Usually, you don't care about this when receiving data. `data` is a pointer to the returned data, and `length` gives the length of the returned data, in bytes. If `length` is negative, then an error occurred and the selection could not be retrieved. This might happen if no application owned the selection, or if you requested a target that the application didn't support. The buffer is actually guaranteed to be one byte longer than `length`; the extra byte will always be zero, so it isn't necessary to make a copy of strings just to null terminate them.

In the following example, we retrieve the special target "TARGETS", which is a list of all targets into which the selection can be converted.

> `

>     /* example-start selection gettargets.c */

>     #include <gtk/gtk.h>

>     void selection_received( GtkWidget        *widget,
>                              GtkSelectionData *selection_data,
>                              gpointer          data );

>     /* Signal handler invoked when user clicks on the "Get Targets" button */
>     void get_targets( GtkWidget *widget,
>                       gpointer data )
>     {
>       static GdkAtom targets_atom = GDK_NONE;

>       /* Get the atom corresponding to the string "TARGETS" */
>       if (targets_atom == GDK_NONE)
>         targets_atom = gdk_atom_intern ("TARGETS", FALSE);

>       /* And request the "TARGETS" target for the primary selection */
>       gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, targets_atom,
>                              GDK_CURRENT_TIME);
>     }

>     /* Signal handler called when the selections owner returns the data */
>     void selection_received( GtkWidget        *widget,
>                              GtkSelectionData *selection_data,
>                              gpointer          data )
>     {
>       GdkAtom *atoms;
>       GList *item_list;
>       int i;

>       /* **** IMPORTANT **** Check to see if retrieval succeeded  */
>       if (selection_data->length < 0)
>         {
>           g_print ("Selection retrieval failed\n");
>           return;
>         }
>       /* Make sure we got the data in the expected form */
>       if (selection_data->type != GDK_SELECTION_TYPE_ATOM)
>         {
>           g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
>           return;
>         }

>       /* Print out the atoms we received */
>       atoms = (GdkAtom *)selection_data->data;

>       item_list = NULL;
>       for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
>         {
>           char *name;
>           name = gdk_atom_name (atoms[i]);
>           if (name != NULL)
>             g_print ("%s\n",name);
>           else
>             g_print ("(bad atom)\n");
>         }

>       return;
>     }

>     int main( int   argc,
>               char *argv[] )
>     {
>       GtkWidget *window;
>       GtkWidget *button;

>       gtk_init (&argc, &argv);

>       /* Create the toplevel window */

>       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
>       gtk_window_set_title (GTK_WINDOW (window), "Event Box");
>       gtk_container_set_border_width (GTK_CONTAINER (window), 10);

>       gtk_signal_connect (GTK_OBJECT (window), "destroy",
>                           GTK_SIGNAL_FUNC (gtk_exit), NULL);

>       /* Create a button the user can click to get targets */

>       button = gtk_button_new_with_label ("Get Targets");
>       gtk_container_add (GTK_CONTAINER (window), button);

>       gtk_signal_connect (GTK_OBJECT(button), "clicked",
>                           GTK_SIGNAL_FUNC (get_targets), NULL);
>       gtk_signal_connect (GTK_OBJECT(button), "selection_received",
>                           GTK_SIGNAL_FUNC (selection_received), NULL);

>       gtk_widget_show (button);
>       gtk_widget_show (window);

>       gtk_main ();

>       return 0;
>     }
>     /* example-end */

> `

## 19.3 Supplying the selection

Supplying the selection is a bit more complicated. You must register handlers that will be called when your selection is requested. For each selection/target pair you will handle, you make a call to:

> `

>     void gtk_selection_add_target (GtkWidget           *widget,
>                                    GdkAtom              selection,
>                                    GdkAtom              target,
>                                    guint                info);

> `

`widget`, `selection`, and `target` identify the requests this handler will manage. When a request for a selection is received, the "selection_get" signal will be called. `info` can be used as an enumerator to identify the specific target within the callback function.

The callback function has the signature:

> `

>     void  "selection_get" (GtkWidget          *widget,
>                            GtkSelectionData   *selection_data,
>                            guint               info,
>                            guint               time);

> `

The GtkSelectionData is the same as above, but this time, we're responsible for filling in the fields `type`, `format`, `data`, and `length`. (The `format` field is actually important here - the X server uses it to figure out whether the data needs to be byte-swapped or not. Usually it will be 8 - i.e. a character - or 32 - i.e. a. integer.) This is done by calling the function:

> `

>     void gtk_selection_data_set( GtkSelectionData *selection_data,
>                                  GdkAtom           type,
>                                  gint              format,
>                                  guchar           *data,
>                                  gint              length );

> `

This function takes care of properly making a copy of the data so that you don't have to worry about keeping it around. (You should not fill in the fields of the GtkSelectionData structure by hand.)

When prompted by the user, you claim ownership of the selection by calling:

> `

>     gint gtk_selection_owner_set( GtkWidget *widget,
>                                   GdkAtom    selection,
>                                   guint32    time );

> `

If another application claims ownership of the selection, you will receive a "selection_clear_event".

As an example of supplying the selection, the following program adds selection functionality to a toggle button. When the toggle button is depressed, the program claims the primary selection. The only target supported (aside from certain targets like "TARGETS" supplied by GTK itself), is the "STRING" target. When this target is requested, a string representation of the time is returned.

> `

>     /* example-start selection setselection.c */

>     #include <gtk/gtk.h>
>     #include <time.h>

>     /* Callback when the user toggles the selection */
>     void selection_toggled( GtkWidget *widget,
>                             gint      *have_selection )
>     {
>       if (GTK_TOGGLE_BUTTON(widget)->active)
>         {
>           *have_selection = gtk_selection_owner_set (widget,
>                                                      GDK_SELECTION_PRIMARY,
>                                                      GDK_CURRENT_TIME);
>           /* if claiming the selection failed, we return the button to
>              the out state */
>           if (!*have_selection)
>             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), FALSE);
>         }
>       else
>         {
>           if (*have_selection)
>             {
>               /* Before clearing the selection by setting the owner to NULL,
>                  we check if we are the actual owner */
>               if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
>                 gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY,
>                                          GDK_CURRENT_TIME);
>               *have_selection = FALSE;
>             }
>         }
>     }

>     /* Called when another application claims the selection */
>     gint selection_clear( GtkWidget         *widget,
>                           GdkEventSelection *event,
>                           gint              *have_selection )
>     {
>       *have_selection = FALSE;
>       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), FALSE);

>       return TRUE;
>     }

>     /* Supplies the current time as the selection. */
>     void selection_handle( GtkWidget        *widget,
>                            GtkSelectionData *selection_data,
>                            guint             info,
>                            guint             time_stamp,
>                            gpointer          data )
>     {
>       gchar *timestr;
>       time_t current_time;

>       current_time = time(NULL);
>       timestr = asctime (localtime(&current_time));
>       /* When we return a single string, it should not be null terminated.
>          That will be done for us */

>       gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
>                               8, timestr, strlen(timestr));
>     }

>     int main( int   argc,
>               char *argv[] )
>     {
>       GtkWidget *window;
>       GtkWidget *selection_button;

>       static int have_selection = FALSE;

>       gtk_init (&argc, &argv);

>       /* Create the toplevel window */

>       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
>       gtk_window_set_title (GTK_WINDOW (window), "Event Box");
>       gtk_container_set_border_width (GTK_CONTAINER (window), 10);

>       gtk_signal_connect (GTK_OBJECT (window), "destroy",
>                           GTK_SIGNAL_FUNC (gtk_exit), NULL);

>       /* Create a toggle button to act as the selection */

>       selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
>       gtk_container_add (GTK_CONTAINER (window), selection_button);
>       gtk_widget_show (selection_button);

>       gtk_signal_connect (GTK_OBJECT(selection_button), "toggled",
>                           GTK_SIGNAL_FUNC (selection_toggled), &have_selection);
>       gtk_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
>                           GTK_SIGNAL_FUNC (selection_clear), &have_selection);

>       gtk_selection_add_target (selection_button,
>                                 GDK_SELECTION_PRIMARY,
>                                 GDK_SELECTION_TYPE_STRING,
>                                 1);
>       gtk_signal_connect (GTK_OBJECT(selection_button), "selection_get",
>                           GTK_SIGNAL_FUNC (selection_handle), &have_selection);

>       gtk_widget_show (selection_button);
>       gtk_widget_show (window);

>       gtk_main ();

>       return 0;
>     }
>     /* example-end */

> `

Next Previous Contents