GI.Gtk.Interfaces.Editable

The Editable interface is an interface which should be implemented by text editing widgets, such as Entry and 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 insertText, an application can convert all entry into a widget into uppercase.

Forcing entry to uppercase.

C code

#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 Text 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 editableInstallProperties, 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 EditableInterface.get_delegate() vfunc returns.

In your instance_init function, create your text widget, and then call editableInitDelegate:

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 editableFinishDelegate 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 editableDelegateSetProperty 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 insertText and deleteText 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 insertText and deleteText signals, you will need to connect to them on the delegate obtained via editableGetDelegate.

Exported types

newtype Editable

Memory-managed wrapper type.

Constructors

Editable (ManagedPtr Editable)

Instances

Eq Editable

Defined in GI.Gtk.Interfaces.Editable

Methods

(==) :: Editable -> Editable -> Bool

(/=) :: Editable -> Editable -> Bool

GObject Editable

Defined in GI.Gtk.Interfaces.Editable

ManagedPtrNewtype Editable

Defined in GI.Gtk.Interfaces.Editable

Methods

toManagedPtr :: Editable -> ManagedPtr Editable

TypedObject Editable

Defined in GI.Gtk.Interfaces.Editable

Methods

glibType :: IO GType

HasParentTypes Editable

Defined in GI.Gtk.Interfaces.Editable

IsGValue (Maybe Editable)

Convert Editable to and from GValue. See toGValue and fromGValue.

Defined in GI.Gtk.Interfaces.Editable

Methods

gvalueGType_ :: IO GType

gvalueSet_ :: Ptr GValue -> Maybe Editable -> IO ()

gvalueGet_ :: Ptr GValue -> IO (Maybe Editable)

type ParentTypes Editable

Defined in GI.Gtk.Interfaces.Editable

type ParentTypes Editable = '[Object, Widget]

class (GObject o, IsDescendantOf Editable o) => IsEditable o

Type class for types which can be safely cast to Editable, for instance with toEditable.

Instances

(GObject o, IsDescendantOf Editable o) => IsEditable o

Defined in GI.Gtk.Interfaces.Editable

toEditable :: (MonadIO m, IsEditable o) => o -> m Editable

Cast to Editable, for types for which this is known to be safe. For general casts, use castTo.

Methods

Click to display all available methods, including inherited ones

Methods

actionSetEnabled, activate, activateAction, activateDefault, addController, addCssClass, addMnemonicLabel, addTickCallback, allocate, bindProperty, bindPropertyFull, childFocus, computeBounds, computeExpand, computePoint, computeTransform, contains, createPangoContext, createPangoLayout, deleteSelection, deleteText, dragCheckThreshold, errorBell, finishDelegate, forceFloating, freezeNotify, getv, grabFocus, hasCssClass, hasDefault, hasFocus, hasVisibleFocus, hide, inDestruction, initDelegate, initTemplate, insertActionGroup, insertAfter, insertBefore, insertText, isAncestor, isDrawable, isFloating, isFocus, isSensitive, isVisible, keynavFailed, listMnemonicLabels, map, measure, mnemonicActivate, notify, notifyByPspec, observeChildren, observeControllers, pick, queueAllocate, queueDraw, queueResize, realize, ref, refSink, removeController, removeCssClass, removeMnemonicLabel, removeTickCallback, resetProperty, resetRelation, resetState, runDispose, selectRegion, shouldLayout, show, sizeAllocate, snapshotChild, stealData, stealQdata, thawNotify, translateCoordinates, triggerTooltipQuery, unmap, unparent, unrealize, unref, unsetStateFlags, updateProperty, updateRelation, updateState, watchClosure.

Getters

getAccessibleRole, getAlignment, getAllocatedBaseline, getAllocatedHeight, getAllocatedWidth, getAllocation, getAncestor, getBuildableId, getCanFocus, getCanTarget, getChars, getChildVisible, getClipboard, getCssClasses, getCssName, getCursor, getData, getDelegate, getDirection, getDisplay, getEditable, getEnableUndo, getFirstChild, getFocusChild, getFocusOnClick, getFocusable, getFontMap, getFontOptions, getFrameClock, getHalign, getHasTooltip, getHeight, getHexpand, getHexpandSet, getLastChild, getLayoutManager, getMapped, getMarginBottom, getMarginEnd, getMarginStart, getMarginTop, getMaxWidthChars, getName, getNative, getNextSibling, getOpacity, getOverflow, getPangoContext, getParent, getPosition, getPreferredSize, getPrevSibling, getPrimaryClipboard, getProperty, getQdata, getRealized, getReceivesDefault, getRequestMode, getRoot, getScaleFactor, getSelectionBounds, getSensitive, getSettings, getSize, getSizeRequest, getStateFlags, getStyleContext, getTemplateChild, getText, getTooltipMarkup, getTooltipText, getValign, getVexpand, getVexpandSet, getVisible, getWidth, getWidthChars.

Setters

setAlignment, setCanFocus, setCanTarget, setChildVisible, setCssClasses, setCursor, setCursorFromName, setData, setDataFull, setDirection, setEditable, setEnableUndo, setFocusChild, setFocusOnClick, setFocusable, setFontMap, setFontOptions, setHalign, setHasTooltip, setHexpand, setHexpandSet, setLayoutManager, setMarginBottom, setMarginEnd, setMarginStart, setMarginTop, setMaxWidthChars, setName, setOpacity, setOverflow, setParent, setPosition, setProperty, setReceivesDefault, setSensitive, setSizeRequest, setStateFlags, setText, setTooltipMarkup, setTooltipText, setValign, setVexpand, setVexpandSet, setVisible, setWidthChars.

delegateGetProperty

editableDelegateGetProperty

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> a

object: a Object

-> Word32

propId: a property ID

-> GValue

value: value to set

-> GParamSpec

pspec: the ParamSpec for the property

-> m Bool

Returns: True if the property was found

Gets a property of the Editable delegate for object.

This is helper function that should be called in get_property, before handling your own properties.

delegateSetProperty

editableDelegateSetProperty

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> a

object: a Object

-> Word32

propId: a property ID

-> GValue

value: value to set

-> GParamSpec

pspec: the ParamSpec for the property

-> m Bool

Returns: True if the property was found

Sets a property on the Editable delegate for object.

This is a helper function that should be called in set_property, before handling your own properties.

deleteSelection

editableDeleteSelection

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m ()

Deletes the currently selected text of the editable. This call doesn’t do anything if there is no selected text.

deleteText

editableDeleteText

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Int32

startPos: start position

-> Int32

endPos: end position

-> m ()

Deletes a sequence of characters. The characters that are deleted are those characters at positions from startPos up to, but not including endPos. If endPos is negative, then the characters deleted are those from startPos to the end of the text.

Note that the positions are specified in characters, not bytes.

finishDelegate

editableFinishDelegate

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m ()

Undoes the setup done by editableInitDelegate.

This is a helper function that should be called from dispose, before removing the delegate object.

getAlignment

editableGetAlignment

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Float

Returns: the alignment

Gets the value set by editableSetAlignment.

getChars

editableGetChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Int32

startPos: start of text

-> Int32

endPos: end of text

-> m Text

Returns: a pointer to the contents of the widget as a string. This string is allocated by the Editable implementation and should be freed by the caller.

Retrieves a sequence of characters. The characters that are retrieved are those characters at positions from startPos up to, but not including endPos. If endPos is negative, then the characters retrieved are those characters from startPos to the end of the text.

Note that positions are specified in characters, not bytes.

getDelegate

editableGetDelegate

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m (Maybe Editable)

Returns: the delegate Editable

Gets the Editable that editable is delegating its implementation to. Typically, the delegate is a Text widget.

getEditable

editableGetEditable

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Bool

Returns: True if editable is editable.

Retrieves whether editable is editable. See editableSetEditable.

getEnableUndo

editableGetEnableUndo

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Bool

Returns: True if undo is enabled

Gets if undo/redo actions are enabled for editable

getMaxWidthChars

editableGetMaxWidthChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Int32

Returns: the maximum width of the entry, in characters

Retrieves the desired maximum width of editable, in characters. See editableSetMaxWidthChars.

getPosition

editableGetPosition

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Int32

Returns: the cursor 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.

getSelectionBounds

editableGetSelectionBounds

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m (Bool, Int32, Int32)

Returns: True if there is a non-empty selection, False otherwise

Retrieves the selection bound of the editable.

startPos will be filled with the start of the selection and endPos with end. If no text was selected both will be identical and False will be returned.

Note that positions are specified in characters, not bytes.

getText

editableGetText

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Text

Returns: a pointer to the contents of the editable.

Retrieves the contents of editable. The returned string is owned by GTK and must not be modified or freed.

getWidthChars

editableGetWidthChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m Int32

Returns: number of chars to request space for, or negative if unset

Gets the value set by editableSetWidthChars.

initDelegate

editableInitDelegate

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m ()

Sets up a delegate for Editable, assuming that the get_delegate vfunc in the Editable interface has been set up for the editable's type.

This is a helper function that should be called in instance init, after creating the delegate object.

insertText

editableInsertText

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Text

text: the text to append

-> Int32

length: the length of the text in bytes, or -1

-> Int32

position: location of the position text will be inserted at

-> m Int32

Inserts length bytes of text into the contents of the widget, at position position.

Note that the position is in characters, not in bytes. The function updates position to point after the newly inserted text.

installProperties

editableInstallProperties

Arguments

:: (HasCallStack, MonadIO m)

=> ObjectClass

objectClass: a ObjectClass

-> Word32

firstProp: property ID to use for the first property

-> m Word32

Returns: the number of properties that were installed

Installs the GtkEditable properties for class.

This is a helper function that should be called in class_init, after installing your own properties.

To handle the properties in your set_property and get_property functions, you can either use editableDelegateSetProperty and editableDelegateGetProperty (if you are using a delegate), or remember the firstProp offset and add it to the values in the EditableProperties enumeration to get the property IDs for these properties.

selectRegion

editableSelectRegion

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Int32

startPos: start of region

-> Int32

endPos: end of region

-> m ()

Selects a region of text.

The characters that are selected are those characters at positions from startPos up to, but not including endPos. If endPos is negative, then the characters selected are those characters from startPos to the end of the text.

Note that positions are specified in characters, not bytes.

setAlignment

editableSetAlignment

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Float

xalign: The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts

-> m ()

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.

setEditable

editableSetEditable

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Bool

isEditable: True if the user is allowed to edit the text in the widget

-> m ()

Determines if the user can edit the text in the editable widget or not.

setEnableUndo

editableSetEnableUndo

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Bool

enableUndo: if undo/redo should be enabled

-> m ()

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 Text:visibility is set to False.

setMaxWidthChars

editableSetMaxWidthChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Int32

nChars: the new desired maximum width, in characters

-> m ()

Sets the desired maximum width in characters of editable.

setPosition

editableSetPosition

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Int32

position: the position of the cursor

-> m ()

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.

setText

editableSetText

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Text

text: the text to set

-> m ()

Sets the text in the editable to the given value, replacing the current contents.

setWidthChars

editableSetWidthChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Int32

nChars: width in chars

-> m ()

Changes the size request of the editable to be about the right size for nChars characters.

Note that it changes the size request, the size can still be affected by how you pack the widget into containers. If nChars is -1, the size reverts to the default size.

Properties

cursorPosition

No description available in the introspection data.

getEditableCursorPosition :: (MonadIO m, IsEditable o) => o -> m Int32

Get the value of the “cursor-position” property. When overloading is enabled, this is equivalent to

get editable #cursorPosition

editable

No description available in the introspection data.

constructEditableEditable :: (IsEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “editable” property. This is rarely needed directly, but it is used by new.

getEditableEditable :: (MonadIO m, IsEditable o) => o -> m Bool

Get the value of the “editable” property. When overloading is enabled, this is equivalent to

get editable #editable

setEditableEditable :: (MonadIO m, IsEditable o) => o -> Bool -> m ()

Set the value of the “editable” property. When overloading is enabled, this is equivalent to

set editable [ #editable := value ]

enableUndo

No description available in the introspection data.

constructEditableEnableUndo :: (IsEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “enable-undo” property. This is rarely needed directly, but it is used by new.

getEditableEnableUndo :: (MonadIO m, IsEditable o) => o -> m Bool

Get the value of the “enable-undo” property. When overloading is enabled, this is equivalent to

get editable #enableUndo

setEditableEnableUndo :: (MonadIO m, IsEditable o) => o -> Bool -> m ()

Set the value of the “enable-undo” property. When overloading is enabled, this is equivalent to

set editable [ #enableUndo := value ]

maxWidthChars

No description available in the introspection data.

constructEditableMaxWidthChars :: (IsEditable o, MonadIO m) => Int32 -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “max-width-chars” property. This is rarely needed directly, but it is used by new.

getEditableMaxWidthChars :: (MonadIO m, IsEditable o) => o -> m Int32

Get the value of the “max-width-chars” property. When overloading is enabled, this is equivalent to

get editable #maxWidthChars

setEditableMaxWidthChars :: (MonadIO m, IsEditable o) => o -> Int32 -> m ()

Set the value of the “max-width-chars” property. When overloading is enabled, this is equivalent to

set editable [ #maxWidthChars := value ]

selectionBound

No description available in the introspection data.

getEditableSelectionBound :: (MonadIO m, IsEditable o) => o -> m Int32

Get the value of the “selection-bound” property. When overloading is enabled, this is equivalent to

get editable #selectionBound

text

No description available in the introspection data.

constructEditableText :: (IsEditable o, MonadIO m) => Text -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “text” property. This is rarely needed directly, but it is used by new.

getEditableText :: (MonadIO m, IsEditable o) => o -> m Text

Get the value of the “text” property. When overloading is enabled, this is equivalent to

get editable #text

setEditableText :: (MonadIO m, IsEditable o) => o -> Text -> m ()

Set the value of the “text” property. When overloading is enabled, this is equivalent to

set editable [ #text := value ]

widthChars

No description available in the introspection data.

constructEditableWidthChars :: (IsEditable o, MonadIO m) => Int32 -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “width-chars” property. This is rarely needed directly, but it is used by new.

getEditableWidthChars :: (MonadIO m, IsEditable o) => o -> m Int32

Get the value of the “width-chars” property. When overloading is enabled, this is equivalent to

get editable #widthChars

setEditableWidthChars :: (MonadIO m, IsEditable o) => o -> Int32 -> m ()

Set the value of the “width-chars” property. When overloading is enabled, this is equivalent to

set editable [ #widthChars := value ]

xalign

No description available in the introspection data.

constructEditableXalign :: (IsEditable o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “xalign” property. This is rarely needed directly, but it is used by new.

getEditableXalign :: (MonadIO m, IsEditable o) => o -> m Float

Get the value of the “xalign” property. When overloading is enabled, this is equivalent to

get editable #xalign

setEditableXalign :: (MonadIO m, IsEditable o) => o -> Float -> m ()

Set the value of the “xalign” property. When overloading is enabled, this is equivalent to

set editable [ #xalign := value ]

Signals

changed

type C_EditableChangedCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EditableChangedCallback = IO ()

The changed signal is emitted at the end of a single user-visible operation on the contents of the Editable.

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 notifytext signals to be emitted).

afterEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId

Connect a signal handler for the changed signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after editable #changed callback

genClosure_EditableChanged :: MonadIO m => EditableChangedCallback -> m (GClosure C_EditableChangedCallback)

Wrap the callback into a GClosure.

mk_EditableChangedCallback :: C_EditableChangedCallback -> IO (FunPtr C_EditableChangedCallback)

Generate a function pointer callable from C code, from a C_EditableChangedCallback.

noEditableChangedCallback :: Maybe EditableChangedCallback

A convenience synonym for Nothing :: Maybe EditableChangedCallback.

onEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId

Connect a signal handler for the changed signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on editable #changed callback

wrap_EditableChangedCallback :: EditableChangedCallback -> C_EditableChangedCallback

Wrap a EditableChangedCallback into a C_EditableChangedCallback.

deleteText

type C_EditableDeleteTextCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EditableDeleteTextCallback

Arguments

 = Int32

startPos: the starting position

-> Int32

endPos: the end position

-> IO ()

This signal is 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 signalStopEmission, it is possible to modify the range of deleted text, or prevent it from being deleted entirely. The startPos and endPos parameters are interpreted as for editableDeleteText.

afterEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId

Connect a signal handler for the deleteText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after editable #deleteText callback

genClosure_EditableDeleteText :: MonadIO m => EditableDeleteTextCallback -> m (GClosure C_EditableDeleteTextCallback)

Wrap the callback into a GClosure.

mk_EditableDeleteTextCallback :: C_EditableDeleteTextCallback -> IO (FunPtr C_EditableDeleteTextCallback)

Generate a function pointer callable from C code, from a C_EditableDeleteTextCallback.

noEditableDeleteTextCallback :: Maybe EditableDeleteTextCallback

A convenience synonym for Nothing :: Maybe EditableDeleteTextCallback.

onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId

Connect a signal handler for the deleteText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on editable #deleteText callback

wrap_EditableDeleteTextCallback :: EditableDeleteTextCallback -> C_EditableDeleteTextCallback

Wrap a EditableDeleteTextCallback into a C_EditableDeleteTextCallback.

insertText

type C_EditableInsertTextCallback = Ptr () -> CString -> Int32 -> Ptr Int32 -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EditableInsertTextCallback

Arguments

 = Text

text: the new text to insert

-> Int32

length: the length of the new text, in bytes, or -1 if new_text is nul-terminated

-> Int32

position: the position, in characters, at which to insert the new text. this is an in-out parameter. After the signal emission is finished, it should point after the newly inserted text.

-> IO Int32

This signal is emitted when text is inserted into the widget by the user. The default handler for this signal will normally be responsible for inserting the text, so by connecting to this signal and then stopping the signal with signalStopEmission, it is possible to modify the inserted text, or prevent it from being inserted entirely.

afterEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId

Connect a signal handler for the insertText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after editable #insertText callback

genClosure_EditableInsertText :: MonadIO m => EditableInsertTextCallback -> m (GClosure C_EditableInsertTextCallback)

Wrap the callback into a GClosure.

mk_EditableInsertTextCallback :: C_EditableInsertTextCallback -> IO (FunPtr C_EditableInsertTextCallback)

Generate a function pointer callable from C code, from a C_EditableInsertTextCallback.

noEditableInsertTextCallback :: Maybe EditableInsertTextCallback

A convenience synonym for Nothing :: Maybe EditableInsertTextCallback.

onEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId

Connect a signal handler for the insertText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on editable #insertText callback

wrap_EditableInsertTextCallback :: EditableInsertTextCallback -> C_EditableInsertTextCallback

Wrap a EditableInsertTextCallback into a C_EditableInsertTextCallback.