Interface

GtkEditable

Description [src]

interface Gtk.Editable : Gtk.Widget

GtkEditable is an interface for text editing widgets.

Typical examples of editable widgets are GtkEntry and GtkSpinButton. It contains functions for generically manipulating an editable widget, a large number of action signals used for key bindings, and several signals that an application can connect to modify the behavior of a widget.

As an example of the latter usage, by connecting the following handler to GtkEditable::insert-text, an application can convert all entry into a widget into uppercase.

Forcing entry to uppercase.

#include <ctype.h>

void
insert_text_handler (GtkEditable *editable,
                     const char  *text,
                     int          length,
                     int         *position,
                     gpointer     data)
{
  char *result = g_utf8_strup (text, length);

  g_signal_handlers_block_by_func (editable,
                               (gpointer) insert_text_handler, data);
  gtk_editable_insert_text (editable, result, length, position);
  g_signal_handlers_unblock_by_func (editable,
                                     (gpointer) insert_text_handler, data);

  g_signal_stop_emission_by_name (editable, "insert_text");

  g_free (result);
}

Implementing GtkEditable

The most likely scenario for implementing GtkEditable on your own widget is that you will embed a GtkText inside a complex widget, and want to delegate the editable functionality to that text widget. GtkEditable provides some utility functions to make this easy.

In your class_init function, call gtk_editable_install_properties(), passing the first available property ID:

static void
my_class_init (MyClass *class)
{
  ...
  g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
  gtk_editable_install_properties (object_clas, NUM_PROPERTIES);
  ...
}

In your interface_init function for the GtkEditable interface, provide an implementation for the get_delegate vfunc that returns your text widget:

GtkEditable *
get_editable_delegate (GtkEditable *editable)
{
  return GTK_EDITABLE (MY_WIDGET (editable)->text_widget);
}

static void
my_editable_init (GtkEditableInterface *iface)
{
  iface->get_delegate = get_editable_delegate;
}

You don’t need to provide any other vfuncs. The default implementations work by forwarding to the delegate that the GtkEditableInterface.get_delegate() vfunc returns.

In your instance_init function, create your text widget, and then call gtk_editable_init_delegate():

static void
my_widget_init (MyWidget *self)
{
  ...
  self->text_widget = gtk_text_new ();
  gtk_editable_init_delegate (GTK_EDITABLE (self));
  ...
}

In your dispose function, call gtk_editable_finish_delegate() before destroying your text widget:

static void
my_widget_dispose (GObject *object)
{
  ...
  gtk_editable_finish_delegate (GTK_EDITABLE (self));
  g_clear_pointer (&self->text_widget, gtk_widget_unparent);
  ...
}

Finally, use gtk_editable_delegate_set_property() in your set_property function (and similar for get_property), to set the editable properties:

  ...
  if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
    return;

  switch (prop_id)
  ...

It is important to note that if you create a GtkEditable that uses a delegate, the low level GtkEditable::insert-text and GtkEditable::delete-text signals will be propagated from the “wrapper” editable to the delegate, but they will not be propagated from the delegate to the “wrapper” editable, as they would cause an infinite recursion. If you wish to connect to the GtkEditable::insert-text and GtkEditable::delete-text signals, you will need to connect to them on the delegate obtained via gtk_editable_get_delegate().

Prerequisite

In order to implement Editable, your type must inherit from GtkWidget.

Implementations

Interface structure

struct GtkEditableInterface {
  GTypeInterface base_iface;
  void (* insert_text) (
    GtkEditable* editable,
    const char* text,
    int length,
    int* position
  );
  void (* delete_text) (
    GtkEditable* editable,
    int start_pos,
    int end_pos
  );
  void (* changed) (
    GtkEditable* editable
  );
  const char* (* get_text) (
    GtkEditable* editable
  );
  void (* do_insert_text) (
    GtkEditable* editable,
    const char* text,
    int length,
    int* position
  );
  void (* do_delete_text) (
    GtkEditable* editable,
    int start_pos,
    int end_pos
  );
  gboolean (* get_selection_bounds) (
    GtkEditable* editable,
    int* start_pos,
    int* end_pos
  );
  void (* set_selection_bounds) (
    GtkEditable* editable,
    int start_pos,
    int end_pos
  );
  GtkEditable* (* get_delegate) (
    GtkEditable* editable
  );
  
}

No description available.

Interface members

`base_iface`	`GTypeInterface`
	No description available.
`insert_text`	`void (* insert_text) ( GtkEditable* editable, const char* text, int length, int* position )`
	No description available.
`delete_text`	`void (* delete_text) ( GtkEditable* editable, int start_pos, int end_pos )`
	No description available.
`changed`	`void (* changed) ( GtkEditable* editable )`
	No description available.
`get_text`	`const char* (* get_text) ( GtkEditable* editable )`
	No description available.
`do_insert_text`	`void (* do_insert_text) ( GtkEditable* editable, const char* text, int length, int* position )`
	No description available.
`do_delete_text`	`void (* do_delete_text) ( GtkEditable* editable, int start_pos, int end_pos )`
	No description available.
`get_selection_bounds`	`gboolean (* get_selection_bounds) ( GtkEditable* editable, int* start_pos, int* end_pos )`
	No description available.
`set_selection_bounds`	`void (* set_selection_bounds) ( GtkEditable* editable, int start_pos, int end_pos )`
	No description available.
`get_delegate`	`GtkEditable* (* get_delegate) ( GtkEditable* editable )`
	No description available.

Description [src]

Forcing entry to uppercase.

Implementing GtkEditable

Prerequisite

Implementations

Functions

Instance methods

Properties

Signals

Interface structure

Interface members

Virtual methods