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 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 gchar *text,
                     gint         length,
                     gint        *position,
                     gpointer     data)
{
  gchar *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);
}

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]

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

bindProperty, bindPropertyFull, copyClipboard, cutClipboard, deleteSelection, deleteText, forceFloating, freezeNotify, getv, insertText, isFloating, notify, notifyByPspec, pasteClipboard, ref, refSink, runDispose, selectRegion, stealData, stealQdata, thawNotify, unref, watchClosure.

Getters

getChars, getData, getEditable, getPosition, getProperty, getQdata, getSelectionBounds.

Setters

setData, setDataFull, setEditable, setPosition, setProperty.

copyClipboard

editableCopyClipboard

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m ()

Copies the contents of the currently selected content in the editable and puts it on the clipboard.

cutClipboard

editableCutClipboard

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m ()

Removes the contents of the currently selected content in the editable and puts it on the clipboard.

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.

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.

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.

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 an area is selected, False otherwise

Retrieves the selection bound of the editable. start_pos 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.

insertText

editableInsertText

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> Text

newText: the text to append

-> Int32

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

-> Int32

position: location of the position text will be inserted at

-> m Int32

Inserts newTextLength bytes of newText 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.

pasteClipboard

editablePasteClipboard

Arguments

:: (HasCallStack, MonadIO m, IsEditable a)

=> a

editable: a Editable

-> m ()

Pastes the content of the clipboard to the current position of the cursor in the editable.

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.

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.

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.

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

newText: the new text to insert

-> Int32

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