Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria |
Safe Haskell | None |
Language | Haskell2010 |
- Exported types
- Methods
- Overloaded methods
- delegateGetProperty
- delegateSetProperty
- deleteSelection
- deleteText
- finishDelegate
- getAlignment
- getChars
- getEditable
- getMaxWidthChars
- getPosition
- getSelectionBounds
- getText
- getWidthChars
- initDelegate
- insertText
- installProperties
- selectRegion
- setAlignment
- setEditable
- setMaxWidthChars
- setPosition
- setText
- setWidthChars
- Properties
- Signals
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 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 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) ...
Synopsis
- newtype Editable = Editable (ManagedPtr Editable)
- noEditable :: Maybe Editable
- class (GObject o, IsDescendantOf Editable o) => IsEditable o
- toEditable :: (MonadIO m, IsEditable o) => o -> m Editable
- editableDelegateGetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> GValue -> GParamSpec -> m Bool
- editableDelegateSetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> GValue -> GParamSpec -> m Bool
- editableDeleteSelection :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableDeleteText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()
- editableFinishDelegate :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableGetAlignment :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Float
- editableGetChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m Text
- editableGetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Bool
- editableGetMaxWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32
- editableGetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32
- editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Bool, Int32, Int32)
- editableGetText :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Text
- editableGetWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32
- editableInitDelegate :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableInsertText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> Int32 -> Int32 -> m Int32
- editableInstallProperties :: (HasCallStack, MonadIO m) => ObjectClass -> Word32 -> m Word32
- editableSelectRegion :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()
- editableSetAlignment :: (HasCallStack, MonadIO m, IsEditable a) => a -> Float -> m ()
- editableSetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> Bool -> m ()
- editableSetMaxWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()
- editableSetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()
- editableSetText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> m ()
- editableSetWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()
- getEditableCursorPosition :: (MonadIO m, IsEditable o) => o -> m Int32
- constructEditableEditable :: IsEditable o => Bool -> IO (GValueConstruct o)
- getEditableEditable :: (MonadIO m, IsEditable o) => o -> m Bool
- setEditableEditable :: (MonadIO m, IsEditable o) => o -> Bool -> m ()
- constructEditableMaxWidthChars :: IsEditable o => Int32 -> IO (GValueConstruct o)
- getEditableMaxWidthChars :: (MonadIO m, IsEditable o) => o -> m Int32
- setEditableMaxWidthChars :: (MonadIO m, IsEditable o) => o -> Int32 -> m ()
- getEditableSelectionBound :: (MonadIO m, IsEditable o) => o -> m Int32
- constructEditableText :: IsEditable o => Text -> IO (GValueConstruct o)
- getEditableText :: (MonadIO m, IsEditable o) => o -> m Text
- setEditableText :: (MonadIO m, IsEditable o) => o -> Text -> m ()
- constructEditableWidthChars :: IsEditable o => Int32 -> IO (GValueConstruct o)
- getEditableWidthChars :: (MonadIO m, IsEditable o) => o -> m Int32
- setEditableWidthChars :: (MonadIO m, IsEditable o) => o -> Int32 -> m ()
- constructEditableXalign :: IsEditable o => Float -> IO (GValueConstruct o)
- getEditableXalign :: (MonadIO m, IsEditable o) => o -> m Float
- setEditableXalign :: (MonadIO m, IsEditable o) => o -> Float -> m ()
- type C_EditableChangedCallback = Ptr () -> Ptr () -> IO ()
- type EditableChangedCallback = IO ()
- afterEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId
- genClosure_EditableChanged :: MonadIO m => EditableChangedCallback -> m (GClosure C_EditableChangedCallback)
- mk_EditableChangedCallback :: C_EditableChangedCallback -> IO (FunPtr C_EditableChangedCallback)
- noEditableChangedCallback :: Maybe EditableChangedCallback
- onEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId
- wrap_EditableChangedCallback :: EditableChangedCallback -> C_EditableChangedCallback
- type C_EditableDeleteTextCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO ()
- type EditableDeleteTextCallback = Int32 -> Int32 -> IO ()
- afterEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId
- genClosure_EditableDeleteText :: MonadIO m => EditableDeleteTextCallback -> m (GClosure C_EditableDeleteTextCallback)
- mk_EditableDeleteTextCallback :: C_EditableDeleteTextCallback -> IO (FunPtr C_EditableDeleteTextCallback)
- noEditableDeleteTextCallback :: Maybe EditableDeleteTextCallback
- onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId
- wrap_EditableDeleteTextCallback :: EditableDeleteTextCallback -> C_EditableDeleteTextCallback
- type C_EditableInsertTextCallback = Ptr () -> CString -> Int32 -> Ptr Int32 -> Ptr () -> IO ()
- type EditableInsertTextCallback = Text -> Int32 -> Int32 -> IO Int32
- afterEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId
- genClosure_EditableInsertText :: MonadIO m => EditableInsertTextCallback -> m (GClosure C_EditableInsertTextCallback)
- mk_EditableInsertTextCallback :: C_EditableInsertTextCallback -> IO (FunPtr C_EditableInsertTextCallback)
- noEditableInsertTextCallback :: Maybe EditableInsertTextCallback
- onEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId
- wrap_EditableInsertTextCallback :: EditableInsertTextCallback -> C_EditableInsertTextCallback
Exported types
Memory-managed wrapper type.
Instances
Eq Editable Source # | |
IsGValue Editable Source # | Convert |
GObject Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable gobjectType :: IO GType # | |
HasParentTypes Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable | |
type ParentTypes Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable |
class (GObject o, IsDescendantOf Editable o) => IsEditable o Source #
Type class for types which can be safely cast to Editable
, for instance with toEditable
.
Instances
(GObject o, IsDescendantOf Editable o) => IsEditable o Source # | |
Defined in GI.Gtk.Interfaces.Editable |
toEditable :: (MonadIO m, IsEditable o) => o -> m Editable Source #
Methods
Overloaded methods
delegateGetProperty
editableDelegateGetProperty Source #
:: (HasCallStack, MonadIO m, IsObject a) | |
=> a |
|
-> Word32 |
|
-> GValue |
|
-> GParamSpec |
|
-> m Bool | Returns: |
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 Source #
:: (HasCallStack, MonadIO m, IsObject a) | |
=> a |
|
-> Word32 |
|
-> GValue |
|
-> GParamSpec |
|
-> m Bool | Returns: |
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 Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m () |
Deletes the currently selected text of the editable. This call doesn’t do anything if there is no selected text.
deleteText
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> 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 Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m () |
Undoes the setup done by editableInitDelegate
.
This is a helper function that should be called from dispose, before removing the delegate object.
getAlignment
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m Float | Returns: the alignment |
Gets the value set by editableSetAlignment
.
getChars
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> m Text | Returns: a pointer to the contents of the widget as a
string. This string is allocated by the |
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
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m Bool | Returns: |
Retrieves whether editable
is editable.
See editableSetEditable
.
getMaxWidthChars
editableGetMaxWidthChars Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m Int32 | Returns: the maximum width of the entry, in characters |
Retrieves the desired maximum width of editable
, in characters.
See editableSetMaxWidthChars
.
getPosition
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> 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 Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m (Bool, Int32, Int32) | Returns: |
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
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> 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 Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m Int32 | Returns: number of chars to request space for, or negative if unset |
Gets the value set by editableSetWidthChars
.
initDelegate
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> m () |
insertText
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Text |
|
-> Int32 |
|
-> Int32 |
|
-> 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 Source #
:: (HasCallStack, MonadIO m) | |
=> ObjectClass |
|
-> Word32 |
|
-> 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
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> 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
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Float |
|
-> 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
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Bool |
|
-> m () |
Determines if the user can edit the text in the editable widget or not.
setMaxWidthChars
editableSetMaxWidthChars Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the desired maximum width in characters of editable
.
setPosition
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Int32 |
|
-> 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
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Text |
|
-> m () |
Sets the text in the editable to the given value, replacing the current contents.
setWidthChars
editableSetWidthChars Source #
:: (HasCallStack, MonadIO m, IsEditable a) | |
=> a |
|
-> Int32 |
|
-> 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 Source #
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 => Bool -> IO (GValueConstruct o) Source #
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 Source #
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 () Source #
Set the value of the “editable
” property.
When overloading is enabled, this is equivalent to
set
editable [ #editable:=
value ]
maxWidthChars
No description available in the introspection data.
constructEditableMaxWidthChars :: IsEditable o => Int32 -> IO (GValueConstruct o) Source #
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 Source #
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 () Source #
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 Source #
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 => Text -> IO (GValueConstruct o) Source #
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 Source #
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 () Source #
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 => Int32 -> IO (GValueConstruct o) Source #
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 Source #
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 () Source #
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 => Float -> IO (GValueConstruct o) Source #
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 Source #
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 () Source #
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 () Source #
Type for the callback on the (unwrapped) C side.
type EditableChangedCallback = IO () Source #
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 Source #
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) Source #
Wrap the callback into a GClosure
.
mk_EditableChangedCallback :: C_EditableChangedCallback -> IO (FunPtr C_EditableChangedCallback) Source #
Generate a function pointer callable from C code, from a C_EditableChangedCallback
.
noEditableChangedCallback :: Maybe EditableChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
EditableChangedCallback
onEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId Source #
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 Source #
Wrap a EditableChangedCallback
into a C_EditableChangedCallback
.
deleteText
type C_EditableDeleteTextCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type EditableDeleteTextCallback Source #
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 Source #
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) Source #
Wrap the callback into a GClosure
.
mk_EditableDeleteTextCallback :: C_EditableDeleteTextCallback -> IO (FunPtr C_EditableDeleteTextCallback) Source #
Generate a function pointer callable from C code, from a C_EditableDeleteTextCallback
.
noEditableDeleteTextCallback :: Maybe EditableDeleteTextCallback Source #
A convenience synonym for
.Nothing
:: Maybe
EditableDeleteTextCallback
onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId Source #
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 Source #
Wrap a EditableDeleteTextCallback
into a C_EditableDeleteTextCallback
.
insertText
type C_EditableInsertTextCallback = Ptr () -> CString -> Int32 -> Ptr Int32 -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type EditableInsertTextCallback Source #
= Text |
|
-> Int32 |
|
-> Int32 |
|
-> 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 Source #
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) Source #
Wrap the callback into a GClosure
.
mk_EditableInsertTextCallback :: C_EditableInsertTextCallback -> IO (FunPtr C_EditableInsertTextCallback) Source #
Generate a function pointer callable from C code, from a C_EditableInsertTextCallback
.
noEditableInsertTextCallback :: Maybe EditableInsertTextCallback Source #
A convenience synonym for
.Nothing
:: Maybe
EditableInsertTextCallback
onEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId Source #
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