GI.Gtk.Interfaces.Editable

GtkEditable is an interface for text editing widgets.

Typical examples of editable widgets are 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 Editable::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 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 editableInstallProperties, passing the first available property ID:

c code

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 code

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 editableInitDelegate:

c code

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:

c code

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:

c code

 ...
 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 Editable::insertText and Editable::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 Editable::insertText and Editable::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, announce, bindProperty, bindPropertyFull, childFocus, computeBounds, computeExpand, computePoint, computeTransform, contains, createPangoContext, createPangoLayout, delegateGetAccessiblePlatformState, deleteSelection, deleteText, disposeTemplate, 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, updateNextAccessibleSibling, updateProperty, updateRelation, updateState, watchClosure.

Getters

getAccessibleParent, getAccessibleRole, getAlignment, getAllocatedBaseline, getAllocatedHeight, getAllocatedWidth, getAllocation, getAncestor, getAtContext, getBaseline, getBounds, getBuildableId, getCanFocus, getCanTarget, getChars, getChildVisible, getClipboard, getColor, getCssClasses, getCssName, getCursor, getData, getDelegate, getDirection, getDisplay, getEditable, getEnableUndo, getFirstAccessibleChild, getFirstChild, getFocusChild, getFocusOnClick, getFocusable, getFontMap, getFontOptions, getFrameClock, getHalign, getHasTooltip, getHeight, getHexpand, getHexpandSet, getLastChild, getLayoutManager, getMapped, getMarginBottom, getMarginEnd, getMarginStart, getMarginTop, getMaxWidthChars, getName, getNative, getNextAccessibleSibling, getNextSibling, getOpacity, getOverflow, getPangoContext, getParent, getPlatformState, 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

setAccessibleParent, 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.

delegateGetAccessiblePlatformState

editableDelegateGetAccessiblePlatformState

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable implementation

-> AccessiblePlatformState

state: what kind of accessible state to retrieve

-> m Bool

Returns: the accessible platform state of the delegate

Retrieves the accessible platform state from the editable delegate.

This is an helper function to retrieve the accessible state for GtkEditable interface implementations using a delegate pattern.

You should call this function in your editable widget implementation of the Accessible.get_platform_state() virtual function, for instance:

c code

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 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 AccessibleRoleTextBox role, or you can change your tree to allow this function to work.

Since: 4.10

delegateGetProperty

editableDelegateGetProperty

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> a

object: a GObject

-> Word32

propId: a property ID

-> GValue

value: value to set

-> GParamSpec

pspec: the GParamSpec for the property

-> m Bool

Returns: True if the property was found

Gets a property of the GtkEditable delegate for object.

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

delegateSetProperty

editableDelegateSetProperty

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> a

object: a GObject

-> Word32

propId: a property ID

-> GValue

value: value to set

-> GParamSpec

pspec: the GParamSpec for the property

-> m Bool

Returns: True if the property was found

Sets a property on the GtkEditable delegate for object.

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

deleteSelection

editableDeleteSelection

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> m Float

Returns: the alignment

Gets the alignment of the editable.

getChars

editableGetChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> 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 GtkEditable 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 GtkEditable

-> m (Maybe Editable)

Returns: the delegate GtkEditable

Gets the GtkEditable 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 GtkEditable

-> m Bool

Returns: True if editable is editable.

Retrieves whether editable is editable.

getEnableUndo

editableGetEnableUndo

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> 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 GtkEditable

-> m Int32

Returns: the maximum width of the entry, in characters

Retrieves the desired maximum width of editable, in characters.

getPosition

editableGetPosition

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> m Int32

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

Gets the number of characters of space reserved for the contents of the editable.

initDelegate

editableInitDelegate

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> m ()

Sets up a delegate for GtkEditable.

This is assuming that the get_delegate vfunc in the GtkEditable 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 GtkEditable

-> Text

text: the text to insert

-> 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 GObjectClass

-> Word32

firstProp: property ID to use for the first property

-> m Word32

Returns: the number of properties that were installed

Overrides the GtkEditable properties for class.

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

Note that your class must have "text", "cursor-position", "selection-bound", "editable", "width-chars", "max-width-chars", "xalign" and "enable-undo" properties for this function to work.

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 GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> 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.

setEnableUndo

editableSetEnableUndo

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> 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 GtkEditable

-> Text

text: the text to set

-> m ()

Sets the text in the editable to the given value.

This is replacing the current contents.

setWidthChars

editableSetWidthChars

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a GtkEditable

-> 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

The current position of the insertion cursor in chars.

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

Whether the entry contents can be edited.

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

If undo/redo should be enabled for the editable.

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

The desired maximum width of the entry, in characters.

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

The position of the opposite end of the selection from the cursor in chars.

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

The contents of the entry.

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

Number of characters to leave space for in the entry.

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

The horizontal alignment, from 0 (left) to 1 (right).

Reversed for RTL layouts.

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 EditableChangedCallback = IO ()

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

afterEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: 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

deleteText

type EditableDeleteTextCallback

Arguments

 = Int32

startPos: the starting position

-> Int32

endPos: the end position

-> IO ()

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: 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

insertText

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

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: 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