[601:7] extends: object
Generated low-level callback wrapper for GIR callback changed.
EditableChangedCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (nativeSelf, nativeUserData)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[741:14] static extends: object
Generated metadata helpers for Editable interface surfaces.
properties ()
Returns property metadata for
Editable.
A list.signals ()
Returns signal metadata for
Editable.
A list.[671:7] extends: object
Generated low-level callback wrapper for GIR callback delete-text.
EditableDeletetextCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (nativeSelf, start_pos, end_pos, nativeUserData)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[63:7] extends: object
Interface for single-line text editing widgets. Typical examples of editable
widgets are [class@Gtk.Entry] and [class@Gtk.SpinButton]. 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
[signal@Gtk.Editable::insert-text], an application can convert all entry into
a widget into uppercase. ## Forcing entry to uppercase. c #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
[func@Gtk.Editable.install_properties], passing the first available property
ID: c 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: c 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
[method@Gtk.Editable.init_delegate]: c 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 [method@Gtk.Editable.finish_delegate] before destroying your
text widget: c 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
[func@Gtk.Editable.delegate_set_property] in your set_property function
(and similar for get_property), to set the editable properties: c ... 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
[signal@Gtk.Editable::insert-text] and [signal@Gtk.Editable::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
[signal@Gtk.Editable::insert-text] and [signal@Gtk.Editable::delete-text]
signals, you will need to connect to them on the delegate obtained via
[method@Gtk.Editable.get_delegate].
Editable (Handle = null)
Creates a new
Editableby wrapping a native handle or another wrapper.
Handle is the native handle or another wrapper whose handle to adopt.toNativeHandle (Source)
Normalizes a constructor argument into a raw pointer carrier. Accepts a raw NativeHandle, a raw NativeBuffer returned from
fn.call(...), another generated wrapper exposinghandle(), or null. Returns null when the argument carries no pointer.
Source is the raw handle, raw buffer, wrapper, or null.A raw pointer carrier or null when no pointer is present.getLib ()
Returns the opened native library for this generated wrapper.
The opened native library.handle ()
Returns the wrapped NativeHandle.
The wrapped NativeHandle.isNull ()
Returns true when the wrapped handle is null.
A bool.describe ()
Returns a small string for debugging generated wrappers.
A string.connectSignal (string Name, CallbackObj)
Connects one generated callback wrapper to a named signal.
Name is the signal name.CallbackObj is the generated callback wrapper to connect.The connected handler id.disconnectSignalHandler (int HandlerId)
Disconnects one retained signal handler id.
HandlerId is the signal handler id to disconnect.None.setOnChanged (callback Fn, UserData = null)
Emitted at the end of a single user-visible operation on the contents. E.g., a paste operation that replaces the contents of the selection will cause only one signal emission (even though it is implemented by first deleting the selection, then inserting the new content, and may cause multiple ::notify::text signals to be emitted).
Fn is the Aussom callback.Fn is called with (Editable Self).UserData is retained and passed through to the generated callback wrapper when provided.The connected handler id.setOnDeletetext (callback Fn, UserData = null)
Emitted when text is deleted from the widget by the user. The default handler for this signal will normally be responsible for deleting the text, so by connecting to this signal and then stopping the signal with g_signal_stop_emission(), it is possible to modify the range of deleted text, or prevent it from being deleted entirely. The @start_pos and
parameters are interpreted as for [method@Gtk.Editable.delete_text].Fn is the Aussom callback.Fn is called with (Editable Self, int Start_pos, int End_pos).UserData is retained and passed through to the generated callback wrapper when provided.The connected handler id.getProperty (string Name)
Reads one generated property by name.
setProperty (string Name, Value)
Writes one generated property by name.
setEditable (bool Value)
Whether the entry contents can be edited.
Value is the new property value.None.setEnableundo (bool Value)
If undo/redo should be enabled for the editable.
Value is the new property value.None.setMaxwidthchars (int Value)
The desired maximum width of the entry, in characters.
Value is the new property value.None.setText (string Value)
The contents of the entry.
Value is the new property value.None.setWidthchars (int Value)
Number of characters to leave space for in the entry.
Value is the new property value.None.setXalign (double Value)
The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts.
Value is the new property value.None.delegate_get_accessible_platform_state (string state)
Retrieves the accessible platform state from the editable delegate. This is an helper function to retrieve the accessible state for
GtkEditableinterface implementations using a delegate pattern. You should call this function in your editable widget implementation of the [vfunc@Gtk.Accessible.get_platform_state] virtual function, for instance:c static void accessible_interface_init (GtkAccessibleInterface *iface) { iface->get_platform_state = your_editable_get_accessible_platform_state; } static gboolean your_editable_get_accessible_platform_state (GtkAccessible *accessible, GtkAccessiblePlatformState state) { return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state); }Note that the widget which is the delegate must be a direct child of this widget, otherwise your implementation of [vfunc@Gtk.Accessible.get_platform_state] might not even be called, as the platform change will originate from the parent of the delegate, and, as a result, will not work properly. So, if you can't ensure the direct child condition, you should give the delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can change your tree to allow this function to work.
state is what kind of accessible state to retrieve.delete_selection ()
Deletes the currently selected text of the editable. This call doesn’t do anything if there is no selected text.
None.delete_text (int start_pos, int end_pos)
Deletes a sequence of characters. The characters that are deleted are those characters at positions from @start_pos up to, but not including
If @end_pos is negative, then the characters deleted are those from @start_pos to the end of the text. Note that the positions are specified in characters, not bytes.start_pos is start position.end_pos is end position.None.finish_delegate ()
Undoes the setup done by [method@Gtk.Editable.init_delegate]. This is a helper function that should be called from dispose, before removing the delegate object.
None.get_alignment ()
Gets the alignment of the editable.
get_chars (int start_pos, int end_pos)
Retrieves a sequence of characters. The characters that are retrieved are those characters at positions from @start_pos up to, but not including
If @end_pos is negative, then the characters retrieved are those characters from @start_pos to the end of the text. Note that positions are specified in characters, not bytes.start_pos is start of text.end_pos is end of text.get_complete_text ()
Retrieves the contents of @editable, including pseudo-content such as the preedit buffer.
get_delegate ()
Gets the
GtkEditablethat @editable is delegating its implementation to. Typically, the delegate is a [class@Gtk.Text] widget.
get_editable ()
Retrieves whether @editable is editable.
get_enable_undo ()
Gets if undo/redo actions are enabled for @editable
get_max_width_chars ()
Retrieves the desired maximum width of @editable, in characters.
get_position ()
Retrieves the current position of the cursor relative to the start of the content of the editable. Note that this position is in characters, not in bytes.
get_text ()
Retrieves the contents of @editable. The returned string is owned by GTK and must not be modified or freed.
get_width_chars ()
Gets the number of characters of space reserved for the contents of the editable.
init_delegate ()
Sets up a delegate for
GtkEditable. This is assuming that the get_delegate vfunc in theGtkEditableinterface has been set up for the
type. This is a helper function that should be called in instance init, after creating the delegate object.None.select_region (int start_pos, int end_pos)
Selects a region of text. The characters that are selected are those characters at positions from @start_pos up to, but not including
If @end_pos is negative, then the characters selected are those characters from @start_pos to the end of the text. Note that positions are specified in characters, not bytes.start_pos is start of region.end_pos is end of region.None.set_alignment (double xalign)
Sets the alignment for the contents of the editable. This controls the horizontal positioning of the contents when the displayed text is shorter than the width of the editable.
xalign is The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts.None.set_editable (bool is_editable)
Determines if the user can edit the text in the editable widget.
is_editable is %TRUE if the user is allowed to edit the text in the widget.None.set_enable_undo (bool enable_undo)
If enabled, changes to @editable will be saved for undo/redo actions. This results in an additional copy of text changes and are not stored in secure memory. As such, undo is forcefully disabled when [property@Gtk.Text:visibility] is set to %FALSE.
enable_undo is if undo/redo should be enabled.None.set_max_width_chars (int n_chars)
Sets the desired maximum width in characters of @editable.
n_chars is the new desired maximum width, in characters.None.set_position (int position)
Sets the cursor position in the editable to the given value. The cursor is displayed before the character with the given (base 0) index in the contents of the editable. The value must be less than or equal to the number of characters in the editable. A value of -1 indicates that the position should be set after the last character of the editable. Note that @position is in characters, not in bytes.
position is the position of the cursor.None.set_text (string text)
Sets the text in the editable to the given value. This is replacing the current contents.
text is the text to set.None.set_width_chars (int n_chars)
Changes the size request of the editable to be about the right size for
characters. Note that it changes the size request, the size can still be affected by how you pack the widget into containers. If @n_chars is -1, the size reverts to the default size.n_chars is width in chars.None.
