| Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
|---|---|
| License | LGPL-2.1 |
| Maintainer | Iñaki García Etxebarria |
| Safe Haskell | Safe-Inferred |
| Language | Haskell2010 |
GI.Gtk.Interfaces.Editable
Description
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);
}Synopsis
- newtype Editable = Editable (ManagedPtr Editable)
- class (GObject o, IsDescendantOf Editable o) => IsEditable o
- toEditable :: (MonadIO m, IsEditable o) => o -> m Editable
- editableCopyClipboard :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableCutClipboard :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableDeleteSelection :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableDeleteText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()
- editableGetChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m Text
- editableGetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Bool
- editableGetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32
- editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Bool, Int32, Int32)
- editableInsertText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> Int32 -> Int32 -> m Int32
- editablePasteClipboard :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()
- editableSelectRegion :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()
- editableSetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> Bool -> m ()
- editableSetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> 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 # | |
| GObject Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable | |
| ManagedPtrNewtype Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable Methods toManagedPtr :: Editable -> ManagedPtr Editable | |
| TypedObject Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable | |
| HasParentTypes Editable Source # | |
Defined in GI.Gtk.Interfaces.Editable | |
| IsGValue (Maybe Editable) Source # | Convert |
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 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
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 Source #
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> m () |
Copies the contents of the currently selected content in the editable and puts it on the clipboard.
cutClipboard
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> m () |
Removes the contents of the currently selected content in the editable and puts it on the clipboard.
deleteSelection
editableDeleteSelection Source #
Arguments
| :: (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
Arguments
| :: (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.
getChars
Arguments
| :: (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
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> m Bool | Returns: |
Retrieves whether editable is editable. See
editableSetEditable.
getPosition
Arguments
| :: (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 #
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> m (Bool, Int32, Int32) |
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
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> Text |
|
| -> Int32 |
|
| -> Int32 |
|
| -> 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 Source #
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> m () |
Pastes the content of the clipboard to the current position of the cursor in the editable.
selectRegion
Arguments
| :: (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.
setEditable
Arguments
| :: (HasCallStack, MonadIO m, IsEditable a) | |
| => a |
|
| -> Bool |
|
| -> m () |
Determines if the user can edit the text in the editable widget or not.
setPosition
Arguments
| :: (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.
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 #
Arguments
| = 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