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 the gtk header file 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:

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:

selection and target are the values you gave in your gtk_selection_convert() call. thetype 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.

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:

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:

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. an integer.) This is done by calling the function:

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 (record) by hand.)

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

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.

You'll see from the screen-shot below that the only visible output is a depressed (but not sad) button. However, if you were to open up a text editor and press Ctrl+V, the current time will be pasted into your document, e.g. 11:50. Alternatively, if you have access to KDE's clipboard tool Klipper, right-click on its icon and you'll see the time added to the selection list each minute. Handy!