Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell	None
Language	Haskell2010

GI.Gtk.Objects.Entry

Contents

Exported types
Methods
Properties
Signals

Description

The Entry widget is a single line text entry widget. A fairly large set of key bindings are supported by default. If the entered text is longer than the allocation of the widget, the widget will scroll so that the cursor position is visible.

When using an entry for passwords and other sensitive information, it can be put into “password mode” using entrySetVisibility. In this mode, entered text is displayed using a “invisible” character. By default, GTK+ picks the best invisible character that is available in the current font, but it can be changed with entrySetInvisibleChar. Since 2.16, GTK+ displays a warning when Caps Lock or input methods might interfere with entering text in a password entry. The warning can be turned off with the Entry:caps-lock-warning property.

Since 2.16, GtkEntry has the ability to display progress or activity information behind the text. To make an entry display such information, use entrySetProgressFraction or entrySetProgressPulseStep.

Additionally, GtkEntry can show icons at either side of the entry. These icons can be activatable by clicking, can be set up as drag source and can have tooltips. To add an icon, use entrySetIconFromGicon or one of the various other functions that set an icon from a stock id, an icon name or a pixbuf. To trigger an action when the user clicks an icon, connect to the Entry::icon-press signal. To allow DND operations from an icon, use entrySetIconDragSource. To set a tooltip on an icon, use entrySetIconTooltipText or the corresponding function for markup.

Note that functionality or information that is only available by clicking on an icon in an entry may not be accessible at all to users which are not able to use a mouse or other pointing device. It is therefore recommended that any such functionality should also be available by other means, e.g. via the context menu of the entry.

CSS nodes

plain code

entry
├── image.left
├── image.right
├── undershoot.left
├── undershoot.right
├── [selection]
├── [progress[.pulse]]
╰── [window.popup]

GtkEntry has a main node with the name entry. Depending on the properties of the entry, the style classes .read-only and .flat may appear. The style classes .warning and .error may also be used with entries.

When the entry shows icons, it adds subnodes with the name image and the style class .left or .right, depending on where the icon appears.

When the entry has a selection, it adds a subnode with the name selection.

When the entry shows progress, it adds a subnode with the name progress. The node has the style class .pulse when the shown progress is pulsing.

The CSS node for a context menu is added as a subnode below entry as well.

The undershoot nodes are used to draw the underflow indication when content is scrolled out of view. These nodes get the .left and .right style classes added depending on where the indication is drawn.

When touch is used and touch selection handles are shown, they are using CSS nodes with name cursor-handle. They get the .top or .bottom style class depending on where they are shown in relation to the selection. If there is just a single handle for the text cursor, it gets the style class .insertion-cursor.

Synopsis

newtype Entry = Entry (ManagedPtr Entry)
class GObject o => IsEntry o
toEntry :: (MonadIO m, IsEntry o) => o -> m Entry
noEntry :: Maybe Entry
entryGetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool
entryGetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Float
entryGetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe AttrList)
entryGetBuffer :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryBuffer
entryGetCompletion :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryCompletion
entryGetCurrentIconDragSource :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32
entryGetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Adjustment)
entryGetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool
entryGetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool
entryGetIconArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Rectangle
entryGetIconAtPos :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> Int32 -> m Int32
entryGetIconGicon :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Icon)
entryGetIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)
entryGetIconPixbuf :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Pixbuf)
entryGetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool
entryGetIconStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Text
entryGetIconStorageType :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m ImageType
entryGetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)
entryGetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)
entryGetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Border)
entryGetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> m [InputHints]
entryGetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> m InputPurpose
entryGetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Char
entryGetLayout :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Layout
entryGetLayoutOffsets :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Int32, Int32)
entryGetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32
entryGetMaxWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32
entryGetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool
entryGetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Text
entryGetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double
entryGetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double
entryGetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe TabArray)
entryGetText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Text
entryGetTextArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Rectangle
entryGetTextLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Word16
entryGetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool
entryGetWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32
entryGrabFocusWithoutSelecting :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()
entryImContextFilterKeypress :: (HasCallStack, MonadIO m, IsEntry a) => a -> EventKey -> m Bool
entryLayoutIndexToTextIndex :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m Int32
entryNew :: (HasCallStack, MonadIO m) => m Entry
entryNewWithBuffer :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Entry
entryProgressPulse :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()
entryResetImContext :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()
entrySetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()
entrySetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> Float -> m ()
entrySetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> AttrList -> m ()
entrySetBuffer :: (HasCallStack, MonadIO m, IsEntry a, IsEntryBuffer b) => a -> b -> m ()
entrySetCompletion :: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b) => a -> Maybe b -> m ()
entrySetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a, IsAdjustment b) => a -> Maybe b -> m ()
entrySetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()
entrySetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()
entrySetIconDragSource :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> TargetList -> [DragAction] -> m ()
entrySetIconFromGicon :: (HasCallStack, MonadIO m, IsEntry a, IsIcon b) => a -> EntryIconPosition -> Maybe b -> m ()
entrySetIconFromIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()
entrySetIconFromPixbuf :: (HasCallStack, MonadIO m, IsEntry a, IsPixbuf b) => a -> EntryIconPosition -> Maybe b -> m ()
entrySetIconFromStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()
entrySetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()
entrySetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()
entrySetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()
entrySetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Border -> m ()
entrySetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> [InputHints] -> m ()
entrySetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> InputPurpose -> m ()
entrySetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> Char -> m ()
entrySetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()
entrySetMaxWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()
entrySetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()
entrySetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Text -> m ()
entrySetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()
entrySetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()
entrySetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> TabArray -> m ()
entrySetText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Text -> m ()
entrySetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()
entrySetWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()
entryTextIndexToLayoutIndex :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m Int32
entryUnsetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()
constructEntryActivatesDefault :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryAttributes :: IsEntry o => AttrList -> IO (GValueConstruct o)
getEntryAttributes :: (MonadIO m, IsEntry o) => o -> m (Maybe AttrList)
setEntryAttributes :: (MonadIO m, IsEntry o) => o -> AttrList -> m ()
constructEntryBuffer :: (IsEntry o, IsEntryBuffer a) => a -> IO (GValueConstruct o)
getEntryBuffer :: (MonadIO m, IsEntry o) => o -> m EntryBuffer
setEntryBuffer :: (MonadIO m, IsEntry o, IsEntryBuffer a) => o -> a -> m ()
constructEntryCapsLockWarning :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntryCompletion :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryCompletion :: (IsEntry o, IsEntryCompletion a) => a -> IO (GValueConstruct o)
getEntryCompletion :: (MonadIO m, IsEntry o) => o -> m EntryCompletion
setEntryCompletion :: (MonadIO m, IsEntry o, IsEntryCompletion a) => o -> a -> m ()
getEntryCursorPosition :: (MonadIO m, IsEntry o) => o -> m Int32
constructEntryEditable :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryEditable :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryEditable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryHasFrame :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryHasFrame :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryHasFrame :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntryImModule :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryImModule :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryImModule :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntryImModule :: (MonadIO m, IsEntry o) => o -> Text -> m ()
clearEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryInnerBorder :: IsEntry o => Border -> IO (GValueConstruct o)
getEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m (Maybe Border)
setEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> Border -> m ()
constructEntryInputHints :: IsEntry o => [InputHints] -> IO (GValueConstruct o)
getEntryInputHints :: (MonadIO m, IsEntry o) => o -> m [InputHints]
setEntryInputHints :: (MonadIO m, IsEntry o) => o -> [InputHints] -> m ()
constructEntryInputPurpose :: IsEntry o => InputPurpose -> IO (GValueConstruct o)
getEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> m InputPurpose
setEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> InputPurpose -> m ()
constructEntryInvisibleChar :: IsEntry o => Word32 -> IO (GValueConstruct o)
getEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> m Word32
setEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> Word32 -> m ()
constructEntryInvisibleCharSet :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryMaxLength :: IsEntry o => Int32 -> IO (GValueConstruct o)
getEntryMaxLength :: (MonadIO m, IsEntry o) => o -> m Int32
setEntryMaxLength :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()
constructEntryMaxWidthChars :: IsEntry o => Int32 -> IO (GValueConstruct o)
getEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32
setEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()
constructEntryOverwriteMode :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPlaceholderText :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m Text
setEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> Text -> m ()
constructEntryPopulateAll :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryPrimaryIconActivatable :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPrimaryIconGicon :: (IsEntry o, IsIcon a) => a -> IO (GValueConstruct o)
getEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)
setEntryPrimaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()
clearEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPrimaryIconName :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()
clearEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPrimaryIconPixbuf :: (IsEntry o, IsPixbuf a) => a -> IO (GValueConstruct o)
getEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf)
setEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m ()
constructEntryPrimaryIconSensitive :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPrimaryIconStock :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m ()
getEntryPrimaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType
clearEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPrimaryIconTooltipMarkup :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()
clearEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()
constructEntryPrimaryIconTooltipText :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()
constructEntryProgressFraction :: IsEntry o => Double -> IO (GValueConstruct o)
getEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> m Double
setEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> Double -> m ()
constructEntryProgressPulseStep :: IsEntry o => Double -> IO (GValueConstruct o)
getEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> m Double
setEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> Double -> m ()
getEntryScrollOffset :: (MonadIO m, IsEntry o) => o -> m Int32
constructEntrySecondaryIconActivatable :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool
setEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()
constructEntrySecondaryIconGicon :: (IsEntry o, IsIcon a) => a -> IO (GValueConstruct o)
getEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)
setEntrySecondaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()
clearEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m ()
constructEntrySecondaryIconName :: IsEntry o => Text -> IO (GValueConstruct o)
getEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()
clearEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m ()
constructEntrySecondaryIconPixbuf :: (IsEntry o, IsPixbuf a) => a -> IO (GValueConstruct o)
getEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf)
setEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m ()
constructEntrySecondaryIconSensitive :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool
setEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
clearEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m ()
constructEntrySecondaryIconStock :: IsEntry o => Text -> IO (GValueConstruct o)
getEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m ()
getEntrySecondaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType
clearEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()
constructEntrySecondaryIconTooltipMarkup :: IsEntry o => Text -> IO (GValueConstruct o)
getEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()
clearEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()
constructEntrySecondaryIconTooltipText :: IsEntry o => Text -> IO (GValueConstruct o)
getEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)
setEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()
getEntrySelectionBound :: (MonadIO m, IsEntry o) => o -> m Int32
constructEntryShadowType :: IsEntry o => ShadowType -> IO (GValueConstruct o)
getEntryShadowType :: (MonadIO m, IsEntry o) => o -> m ShadowType
setEntryShadowType :: (MonadIO m, IsEntry o) => o -> ShadowType -> m ()
constructEntryShowEmojiIcon :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryTabs :: IsEntry o => TabArray -> IO (GValueConstruct o)
getEntryTabs :: (MonadIO m, IsEntry o) => o -> m (Maybe TabArray)
setEntryTabs :: (MonadIO m, IsEntry o) => o -> TabArray -> m ()
constructEntryText :: IsEntry o => Text -> IO (GValueConstruct o)
getEntryText :: (MonadIO m, IsEntry o) => o -> m Text
setEntryText :: (MonadIO m, IsEntry o) => o -> Text -> m ()
getEntryTextLength :: (MonadIO m, IsEntry o) => o -> m Word32
constructEntryTruncateMultiline :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryVisibility :: IsEntry o => Bool -> IO (GValueConstruct o)
getEntryVisibility :: (MonadIO m, IsEntry o) => o -> m Bool
setEntryVisibility :: (MonadIO m, IsEntry o) => o -> Bool -> m ()
constructEntryWidthChars :: IsEntry o => Int32 -> IO (GValueConstruct o)
getEntryWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32
setEntryWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()
constructEntryXalign :: IsEntry o => Float -> IO (GValueConstruct o)
getEntryXalign :: (MonadIO m, IsEntry o) => o -> m Float
setEntryXalign :: (MonadIO m, IsEntry o) => o -> Float -> m ()
type C_EntryActivateCallback = Ptr () -> Ptr () -> IO ()
type EntryActivateCallback = IO ()
afterEntryActivate :: (IsEntry a, MonadIO m) => a -> EntryActivateCallback -> m SignalHandlerId
genClosure_EntryActivate :: EntryActivateCallback -> IO Closure
mk_EntryActivateCallback :: C_EntryActivateCallback -> IO (FunPtr C_EntryActivateCallback)
noEntryActivateCallback :: Maybe EntryActivateCallback
onEntryActivate :: (IsEntry a, MonadIO m) => a -> EntryActivateCallback -> m SignalHandlerId
wrap_EntryActivateCallback :: EntryActivateCallback -> C_EntryActivateCallback
type C_EntryBackspaceCallback = Ptr () -> Ptr () -> IO ()
type EntryBackspaceCallback = IO ()
afterEntryBackspace :: (IsEntry a, MonadIO m) => a -> EntryBackspaceCallback -> m SignalHandlerId
genClosure_EntryBackspace :: EntryBackspaceCallback -> IO Closure
mk_EntryBackspaceCallback :: C_EntryBackspaceCallback -> IO (FunPtr C_EntryBackspaceCallback)
noEntryBackspaceCallback :: Maybe EntryBackspaceCallback
onEntryBackspace :: (IsEntry a, MonadIO m) => a -> EntryBackspaceCallback -> m SignalHandlerId
wrap_EntryBackspaceCallback :: EntryBackspaceCallback -> C_EntryBackspaceCallback
type C_EntryCopyClipboardCallback = Ptr () -> Ptr () -> IO ()
type EntryCopyClipboardCallback = IO ()
afterEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> EntryCopyClipboardCallback -> m SignalHandlerId
genClosure_EntryCopyClipboard :: EntryCopyClipboardCallback -> IO Closure
mk_EntryCopyClipboardCallback :: C_EntryCopyClipboardCallback -> IO (FunPtr C_EntryCopyClipboardCallback)
noEntryCopyClipboardCallback :: Maybe EntryCopyClipboardCallback
onEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> EntryCopyClipboardCallback -> m SignalHandlerId
wrap_EntryCopyClipboardCallback :: EntryCopyClipboardCallback -> C_EntryCopyClipboardCallback
type C_EntryCutClipboardCallback = Ptr () -> Ptr () -> IO ()
type EntryCutClipboardCallback = IO ()
afterEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> EntryCutClipboardCallback -> m SignalHandlerId
genClosure_EntryCutClipboard :: EntryCutClipboardCallback -> IO Closure
mk_EntryCutClipboardCallback :: C_EntryCutClipboardCallback -> IO (FunPtr C_EntryCutClipboardCallback)
noEntryCutClipboardCallback :: Maybe EntryCutClipboardCallback
onEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> EntryCutClipboardCallback -> m SignalHandlerId
wrap_EntryCutClipboardCallback :: EntryCutClipboardCallback -> C_EntryCutClipboardCallback
type C_EntryDeleteFromCursorCallback = Ptr () -> CUInt -> Int32 -> Ptr () -> IO ()
type EntryDeleteFromCursorCallback = DeleteType -> Int32 -> IO ()
afterEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> EntryDeleteFromCursorCallback -> m SignalHandlerId
genClosure_EntryDeleteFromCursor :: EntryDeleteFromCursorCallback -> IO Closure
mk_EntryDeleteFromCursorCallback :: C_EntryDeleteFromCursorCallback -> IO (FunPtr C_EntryDeleteFromCursorCallback)
noEntryDeleteFromCursorCallback :: Maybe EntryDeleteFromCursorCallback
onEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> EntryDeleteFromCursorCallback -> m SignalHandlerId
wrap_EntryDeleteFromCursorCallback :: EntryDeleteFromCursorCallback -> C_EntryDeleteFromCursorCallback
type C_EntryIconPressCallback = Ptr () -> CUInt -> Ptr EventButton -> Ptr () -> IO ()
type EntryIconPressCallback = EntryIconPosition -> EventButton -> IO ()
afterEntryIconPress :: (IsEntry a, MonadIO m) => a -> EntryIconPressCallback -> m SignalHandlerId
genClosure_EntryIconPress :: EntryIconPressCallback -> IO Closure
mk_EntryIconPressCallback :: C_EntryIconPressCallback -> IO (FunPtr C_EntryIconPressCallback)
noEntryIconPressCallback :: Maybe EntryIconPressCallback
onEntryIconPress :: (IsEntry a, MonadIO m) => a -> EntryIconPressCallback -> m SignalHandlerId
wrap_EntryIconPressCallback :: EntryIconPressCallback -> C_EntryIconPressCallback
type C_EntryIconReleaseCallback = Ptr () -> CUInt -> Ptr EventButton -> Ptr () -> IO ()
type EntryIconReleaseCallback = EntryIconPosition -> EventButton -> IO ()
afterEntryIconRelease :: (IsEntry a, MonadIO m) => a -> EntryIconReleaseCallback -> m SignalHandlerId
genClosure_EntryIconRelease :: EntryIconReleaseCallback -> IO Closure
mk_EntryIconReleaseCallback :: C_EntryIconReleaseCallback -> IO (FunPtr C_EntryIconReleaseCallback)
noEntryIconReleaseCallback :: Maybe EntryIconReleaseCallback
onEntryIconRelease :: (IsEntry a, MonadIO m) => a -> EntryIconReleaseCallback -> m SignalHandlerId
wrap_EntryIconReleaseCallback :: EntryIconReleaseCallback -> C_EntryIconReleaseCallback
type C_EntryInsertAtCursorCallback = Ptr () -> CString -> Ptr () -> IO ()
type EntryInsertAtCursorCallback = Text -> IO ()
afterEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> EntryInsertAtCursorCallback -> m SignalHandlerId
genClosure_EntryInsertAtCursor :: EntryInsertAtCursorCallback -> IO Closure
mk_EntryInsertAtCursorCallback :: C_EntryInsertAtCursorCallback -> IO (FunPtr C_EntryInsertAtCursorCallback)
noEntryInsertAtCursorCallback :: Maybe EntryInsertAtCursorCallback
onEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> EntryInsertAtCursorCallback -> m SignalHandlerId
wrap_EntryInsertAtCursorCallback :: EntryInsertAtCursorCallback -> C_EntryInsertAtCursorCallback
type C_EntryInsertEmojiCallback = Ptr () -> Ptr () -> IO ()
type EntryInsertEmojiCallback = IO ()
afterEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> EntryInsertEmojiCallback -> m SignalHandlerId
genClosure_EntryInsertEmoji :: EntryInsertEmojiCallback -> IO Closure
mk_EntryInsertEmojiCallback :: C_EntryInsertEmojiCallback -> IO (FunPtr C_EntryInsertEmojiCallback)
noEntryInsertEmojiCallback :: Maybe EntryInsertEmojiCallback
onEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> EntryInsertEmojiCallback -> m SignalHandlerId
wrap_EntryInsertEmojiCallback :: EntryInsertEmojiCallback -> C_EntryInsertEmojiCallback
type C_EntryMoveCursorCallback = Ptr () -> CUInt -> Int32 -> CInt -> Ptr () -> IO ()
type EntryMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()
afterEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> EntryMoveCursorCallback -> m SignalHandlerId
genClosure_EntryMoveCursor :: EntryMoveCursorCallback -> IO Closure
mk_EntryMoveCursorCallback :: C_EntryMoveCursorCallback -> IO (FunPtr C_EntryMoveCursorCallback)
noEntryMoveCursorCallback :: Maybe EntryMoveCursorCallback
onEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> EntryMoveCursorCallback -> m SignalHandlerId
wrap_EntryMoveCursorCallback :: EntryMoveCursorCallback -> C_EntryMoveCursorCallback
type C_EntryPasteClipboardCallback = Ptr () -> Ptr () -> IO ()
type EntryPasteClipboardCallback = IO ()
afterEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> EntryPasteClipboardCallback -> m SignalHandlerId
genClosure_EntryPasteClipboard :: EntryPasteClipboardCallback -> IO Closure
mk_EntryPasteClipboardCallback :: C_EntryPasteClipboardCallback -> IO (FunPtr C_EntryPasteClipboardCallback)
noEntryPasteClipboardCallback :: Maybe EntryPasteClipboardCallback
onEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> EntryPasteClipboardCallback -> m SignalHandlerId
wrap_EntryPasteClipboardCallback :: EntryPasteClipboardCallback -> C_EntryPasteClipboardCallback
type C_EntryPopulatePopupCallback = Ptr () -> Ptr Widget -> Ptr () -> IO ()
type EntryPopulatePopupCallback = Widget -> IO ()
afterEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> EntryPopulatePopupCallback -> m SignalHandlerId
genClosure_EntryPopulatePopup :: EntryPopulatePopupCallback -> IO Closure
mk_EntryPopulatePopupCallback :: C_EntryPopulatePopupCallback -> IO (FunPtr C_EntryPopulatePopupCallback)
noEntryPopulatePopupCallback :: Maybe EntryPopulatePopupCallback
onEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> EntryPopulatePopupCallback -> m SignalHandlerId
wrap_EntryPopulatePopupCallback :: EntryPopulatePopupCallback -> C_EntryPopulatePopupCallback
type C_EntryPreeditChangedCallback = Ptr () -> CString -> Ptr () -> IO ()
type EntryPreeditChangedCallback = Text -> IO ()
afterEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> EntryPreeditChangedCallback -> m SignalHandlerId
genClosure_EntryPreeditChanged :: EntryPreeditChangedCallback -> IO Closure
mk_EntryPreeditChangedCallback :: C_EntryPreeditChangedCallback -> IO (FunPtr C_EntryPreeditChangedCallback)
noEntryPreeditChangedCallback :: Maybe EntryPreeditChangedCallback
onEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> EntryPreeditChangedCallback -> m SignalHandlerId
wrap_EntryPreeditChangedCallback :: EntryPreeditChangedCallback -> C_EntryPreeditChangedCallback
type C_EntryToggleOverwriteCallback = Ptr () -> Ptr () -> IO ()
type EntryToggleOverwriteCallback = IO ()
afterEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> EntryToggleOverwriteCallback -> m SignalHandlerId
genClosure_EntryToggleOverwrite :: EntryToggleOverwriteCallback -> IO Closure
mk_EntryToggleOverwriteCallback :: C_EntryToggleOverwriteCallback -> IO (FunPtr C_EntryToggleOverwriteCallback)
noEntryToggleOverwriteCallback :: Maybe EntryToggleOverwriteCallback
onEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> EntryToggleOverwriteCallback -> m SignalHandlerId
wrap_EntryToggleOverwriteCallback :: EntryToggleOverwriteCallback -> C_EntryToggleOverwriteCallback

Exported types

newtype Entry Source #

Memory-managed wrapper type.

Constructors

Entry (ManagedPtr Entry)

Instances

GObject Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry Methods gobjectType :: Entry -> IO GType #
IsImplementorIface Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsObject Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsBuildable Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsCellEditable Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsEditable Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsEntry Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsWidget Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry

class GObject o => IsEntry o Source #

Type class for types which can be safely cast to Entry, for instance with toEntry.

Instances

(GObject a, (UnknownAncestorError Entry a :: Constraint)) => IsEntry a Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsEntry Entry Source #
Instance details Defined in GI.Gtk.Objects.Entry
IsEntry SpinButton Source #
Instance details Defined in GI.Gtk.Objects.SpinButton
IsEntry SearchEntry Source #
Instance details Defined in GI.Gtk.Objects.SearchEntry

toEntry :: (MonadIO m, IsEntry o) => o -> m Entry Source #

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

noEntry :: Maybe Entry Source #

A convenience alias for Nothing :: Maybe Entry.

Methods

getActivatesDefault

entryGetActivatesDefault Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Bool	Returns: `True` if the entry will activate the default widget

Retrieves the value set by entrySetActivatesDefault.

getAlignment

entryGetAlignment Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Float	Returns: the alignment

Gets the value set by entrySetAlignment.

Since: 2.4

getAttributes

entryGetAttributes Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m (Maybe AttrList)	Returns: the attribute list, or `Nothing` if none was set.

Gets the attribute list that was set on the entry using entrySetAttributes, if any.

Since: 3.6

getBuffer

entryGetBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m EntryBuffer	Returns: A `EntryBuffer` object.

Get the EntryBuffer object which holds the text for this widget.

Since: 2.18

getCompletion

entryGetCompletion Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> m EntryCompletion	Returns: The auxiliary completion object currently in use by `entry`.

Returns the auxiliary completion object currently in use by entry.

Since: 2.4

getCurrentIconDragSource

entryGetCurrentIconDragSource Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Int32	Returns: index of the icon which is the source of the current DND operation, or -1.

Returns the index of the icon which is the source of the current DND operation, or -1.

This function is meant to be used in a Widget::drag-data-get callback.

Since: 2.16

getCursorHadjustment

entryGetCursorHadjustment Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m (Maybe Adjustment)	Returns: the horizontal cursor adjustment, or `Nothing` if none has been set.

Retrieves the horizontal cursor adjustment for the entry. See entrySetCursorHadjustment.

Since: 2.12

getHasFrame

entryGetHasFrame Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Bool	Returns: whether the entry has a beveled frame

Gets the value set by entrySetHasFrame.

getIconActivatable

entryGetIconActivatable Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m Bool	Returns: `True` if the icon is activatable.

Returns whether the icon is activatable.

Since: 2.16

getIconArea

entryGetIconArea Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m Rectangle

Gets the area where entry’s icon at iconPos is drawn. This function is useful when drawing something to the entry in a draw callback.

If the entry is not realized or has no icon at the given position, iconArea is filled with zeros. Otherwise, iconArea will be filled with the icon’s allocation, relative to entry’s allocation.

getIconAtPos

entryGetIconAtPos Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Int32	`x`: the x coordinate of the position to find
-> Int32	`y`: the y coordinate of the position to find
-> m Int32	Returns: the index of the icon at the given position, or -1

Finds the icon at the given position and return its index. The position’s coordinates are relative to the entry’s top left corner. If x, y doesn’t lie inside an icon, -1 is returned. This function is intended for use in a Widget::query-tooltip signal handler.

Since: 2.16

getIconGicon

entryGetIconGicon Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m (Maybe Icon)	Returns: A `Icon`, or `Nothing` if no icon is set or if the icon is not a `Icon`

Retrieves the Icon used for the icon, or Nothing if there is no icon or if the icon was set by some other method (e.g., by stock, pixbuf, or icon name).

Since: 2.16

getIconName

entryGetIconName Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m (Maybe Text)	Returns: An icon name, or `Nothing` if no icon is set or if the icon wasn’t set from an icon name

Retrieves the icon name used for the icon, or Nothing if there is no icon or if the icon was set by some other method (e.g., by pixbuf, stock or gicon).

Since: 2.16

getIconPixbuf

entryGetIconPixbuf Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m (Maybe Pixbuf)	Returns: A `Pixbuf`, or `Nothing` if no icon is set for this position.

Retrieves the image used for the icon.

Unlike the other methods of setting and getting icon data, this method will work regardless of whether the icon was set using a Pixbuf, a Icon, a stock item, or an icon name.

Since: 2.16

getIconSensitive

entryGetIconSensitive Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m Bool	Returns: `True` if the icon is sensitive.

Returns whether the icon appears sensitive or insensitive.

Since: 2.16

getIconStock

entryGetIconStock Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m Text	Returns: A stock id, or `Nothing` if no icon is set or if the icon wasn’t set from a stock id

Deprecated: (Since version 3.10)Use entryGetIconName instead.

Retrieves the stock id used for the icon, or Nothing if there is no icon or if the icon was set by some other method (e.g., by pixbuf, icon name or gicon).

Since: 2.16

getIconStorageType

entryGetIconStorageType Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> m ImageType	Returns: image representation being used

Gets the type of representation being used by the icon to store image data. If the icon has no image data, the return value will be ImageTypeEmpty.

Since: 2.16

getIconTooltipMarkup

entryGetIconTooltipMarkup Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: the icon position
-> m (Maybe Text)	Returns: the tooltip text, or `Nothing`. Free the returned string with `free` when done.

Gets the contents of the tooltip on the icon at the specified position in entry.

Since: 2.16

getIconTooltipText

entryGetIconTooltipText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: the icon position
-> m (Maybe Text)	Returns: the tooltip text, or `Nothing`. Free the returned string with `free` when done.

Gets the contents of the tooltip on the icon at the specified position in entry.

Since: 2.16

getInnerBorder

entryGetInnerBorder Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m (Maybe Border)	Returns: the entry’s `Border`, or `Nothing` if none was set.

Deprecated: (Since version 3.4)Use the standard border and padding CSS properties (through objects like StyleContext and CssProvider); the value returned by this function is ignored by Entry.

This function returns the entry’s Entry:inner-border property. See entrySetInnerBorder for more information.

Since: 2.10

getInputHints

entryGetInputHints Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m [InputHints]

Gets the value of the Entry:input-hints property.

Since: 3.6

getInputPurpose

entryGetInputPurpose Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m InputPurpose

Gets the value of the Entry:input-purpose property.

Since: 3.6

getInvisibleChar

entryGetInvisibleChar Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Char	Returns: the current invisible char, or 0, if the entry does not show invisible text at all.

Retrieves the character displayed in place of the real characters for entries with visibility set to false. See entrySetInvisibleChar.

getLayout

entryGetLayout Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Layout	Returns: the `Layout` for this entry

Gets the Layout used to display the entry. The layout is useful to e.g. convert text positions to pixel positions, in combination with entryGetLayoutOffsets. The returned layout is owned by the entry and must not be modified or freed by the caller.

Keep in mind that the layout text may contain a preedit string, so entryLayoutIndexToTextIndex and entryTextIndexToLayoutIndex are needed to convert byte indices in the layout to byte indices in the entry contents.

getLayoutOffsets

entryGetLayoutOffsets Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m (Int32, Int32)

Obtains the position of the Layout used to render text in the entry, in widget coordinates. Useful if you want to line up the text in an entry with some other text, e.g. when using the entry to implement editable cells in a sheet widget.

Also useful to convert mouse events into coordinates inside the Layout, e.g. to take some action if some part of the entry text is clicked.

Note that as the user scrolls around in the entry the offsets will change; you’ll need to connect to the “notify::scroll-offset” signal to track this. Remember when using the Layout functions you need to convert to and from pixels using PANGO_PIXELS() or SCALE.

Keep in mind that the layout text may contain a preedit string, so entryLayoutIndexToTextIndex and entryTextIndexToLayoutIndex are needed to convert byte indices in the layout to byte indices in the entry contents.

getMaxLength

entryGetMaxLength Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Int32	Returns: the maximum allowed number of characters in `Entry`, or 0 if there is no maximum.

Retrieves the maximum allowed length of the text in entry. See entrySetMaxLength.

This is equivalent to getting entry's EntryBuffer and calling entryBufferGetMaxLength on it.

getMaxWidthChars

entryGetMaxWidthChars Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Int32	Returns: the maximum width of the entry, in characters

Retrieves the desired maximum width of entry, in characters. See entrySetMaxWidthChars.

Since: 3.12

getOverwriteMode

entryGetOverwriteMode Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Bool	Returns: whether the text is overwritten when typing.

Gets the value set by entrySetOverwriteMode.

Since: 2.14

getPlaceholderText

entryGetPlaceholderText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Text	Returns: a pointer to the placeholder text as a string. This string points to internally allocated storage in the widget and must not be freed, modified or stored.

Retrieves the text that will be displayed when entry is empty and unfocused

Since: 3.2

getProgressFraction

entryGetProgressFraction Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Double	Returns: a fraction from 0.0 to 1.0

Returns the current fraction of the task that’s been completed. See entrySetProgressFraction.

Since: 2.16

getProgressPulseStep

entryGetProgressPulseStep Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Double	Returns: a fraction from 0.0 to 1.0

Retrieves the pulse step set with entrySetProgressPulseStep.

Since: 2.16

getTabs

entryGetTabs Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m (Maybe TabArray)	Returns: the tabstops, or `Nothing` if none was set.

Gets the tabstops that were set on the entry using entrySetTabs, if any.

Since: 3.10

getText

entryGetText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Text	Returns: a pointer to the contents of the widget as a string. This string points to internally allocated storage in the widget and must not be freed, modified or stored.

Retrieves the contents of the entry widget. See also editableGetChars.

This is equivalent to getting entry's EntryBuffer and calling entryBufferGetText on it.

getTextArea

entryGetTextArea Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Rectangle

Gets the area where the entry’s text is drawn. This function is useful when drawing something to the entry in a draw callback.

If the entry is not realized, textArea is filled with zeros.

getTextLength

entryGetTextLength Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Word16	Returns: the current number of characters in `Entry`, or 0 if there are none.

Retrieves the current length of the text in entry.

This is equivalent to getting entry's EntryBuffer and calling entryBufferGetLength on it.

Since: 2.14

getVisibility

entryGetVisibility Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Bool	Returns: `True` if the text is currently visible

Retrieves whether the text in entry is visible. See entrySetVisibility.

getWidthChars

entryGetWidthChars Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m Int32	Returns: number of chars to request space for, or negative if unset

Gets the value set by entrySetWidthChars.

grabFocusWithoutSelecting

entryGrabFocusWithoutSelecting Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m ()

Causes entry to have keyboard focus.

It behaves like widgetGrabFocus, except that it doesn't select the contents of the entry. You only want to call this on some special entries which the user usually doesn't want to replace all text in, such as search-as-you-type entries.

Since: 3.16

imContextFilterKeypress

entryImContextFilterKeypress Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EventKey	`event`: the key event
-> m Bool	Returns: `True` if the input method handled the key event.

Allow the Entry input method to internally handle key press and release events. If this function returns True, then no further processing should be done for this key event. See iMContextFilterKeypress.

Note that you are expected to call this function from your handler when overriding key event handling. This is needed in the case when you need to insert your own key handling between the input method and the default key event handling of the Entry. See textViewResetImContext for an example of use.

Since: 2.22

layoutIndexToTextIndex

entryLayoutIndexToTextIndex Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Int32	`layoutIndex`: byte index into the entry layout text
-> m Int32	Returns: byte index into the entry contents

Converts from a position in the entry’s Layout (returned by entryGetLayout) to a position in the entry contents (returned by entryGetText).

new

entryNew Source #

Arguments

:: (HasCallStack, MonadIO m)
=> m Entry	Returns: a new `Entry`.

Creates a new entry.

newWithBuffer

entryNewWithBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntryBuffer a)
=> a	`buffer`: The buffer to use for the new `Entry`.
-> m Entry	Returns: a new `Entry`

Creates a new entry with the specified text buffer.

Since: 2.18

progressPulse

entryProgressPulse Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m ()

Indicates that some progress is made, but you don’t know how much. Causes the entry’s progress indicator to enter “activity mode,” where a block bounces back and forth. Each call to entryProgressPulse causes the block to move by a little bit (the amount of movement per pulse is determined by entrySetProgressPulseStep).

Since: 2.16

resetImContext

entryResetImContext Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m ()

Reset the input method context of the entry if needed.

This can be necessary in the case where modifying the buffer would confuse on-going input method behavior.

Since: 2.22

setActivatesDefault

entrySetActivatesDefault Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Bool	`setting`: `True` to activate window’s default widget on Enter keypress
-> m ()

If setting is True, pressing Enter in the entry will activate the default widget for the window containing the entry. This usually means that the dialog box containing the entry will be closed, since the default widget is usually one of the dialog buttons.

(For experts: if setting is True, the entry calls windowActivateDefault on the window containing the entry, in the default handler for the Entry::activate signal.)

setAlignment

entrySetAlignment Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Float	`xalign`: The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts
-> m ()

Sets the alignment for the contents of the entry. This controls the horizontal positioning of the contents when the displayed text is shorter than the width of the entry.

Since: 2.4

setAttributes

entrySetAttributes Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> AttrList	`attrs`: a `AttrList`
-> m ()

Sets a AttrList; the attributes in the list are applied to the entry text.

Since: 3.6

setBuffer

entrySetBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a, IsEntryBuffer b)
=> a	`entry`: a `Entry`
-> b	`buffer`: a `EntryBuffer`
-> m ()

Set the EntryBuffer object which holds the text for this widget.

Since: 2.18

setCompletion

entrySetCompletion Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b)
=> a	`entry`: A `Entry`
-> Maybe b	`completion`: The `EntryCompletion` or `Nothing`
-> m ()

Sets completion to be the auxiliary completion object to use with entry. All further configuration of the completion mechanism is done on completion using the EntryCompletion API. Completion is disabled if completion is set to Nothing.

Since: 2.4

setCursorHadjustment

entrySetCursorHadjustment Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a, IsAdjustment b)
=> a	`entry`: a `Entry`
-> Maybe b	`adjustment`: an adjustment which should be adjusted when the cursor is moved, or `Nothing`
-> m ()

Hooks up an adjustment to the cursor position in an entry, so that when the cursor is moved, the adjustment is scrolled to show that position. See scrolledWindowGetHadjustment for a typical way of obtaining the adjustment.

The adjustment has to be in pixel units and in the same coordinate system as the entry.

Since: 2.12

setHasFrame

entrySetHasFrame Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Bool	`setting`: new value
-> m ()

Sets whether the entry has a beveled frame around it.

setIconActivatable

entrySetIconActivatable Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> Bool	`activatable`: `True` if the icon should be activatable
-> m ()

Sets whether the icon is activatable.

Since: 2.16

setIconDragSource

entrySetIconDragSource Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: icon position
-> TargetList	`targetList`: the targets (data formats) in which the data can be provided
-> [DragAction]	`actions`: a bitmask of the allowed drag actions
-> m ()

Sets up the icon at the given position so that GTK+ will start a drag operation when the user clicks and drags the icon.

To handle the drag operation, you need to connect to the usual Widget::drag-data-get (or possibly Widget::drag-data-delete) signal, and use entryGetCurrentIconDragSource in your signal handler to find out if the drag was started from an icon.

By default, GTK+ uses the icon as the drag icon. You can use the Widget::drag-begin signal to set a different icon. Note that you have to use g_signal_connect_after() to ensure that your signal handler gets executed after the default handler.

Since: 2.16

setIconFromGicon

entrySetIconFromGicon Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a, IsIcon b)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: The position at which to set the icon
-> Maybe b	`icon`: The icon to set, or `Nothing`
-> m ()

Sets the icon shown in the entry at the specified position from the current icon theme. If the icon isn’t known, a “broken image” icon will be displayed instead.

If icon is Nothing, no icon will be shown in the specified position.

Since: 2.16

setIconFromIconName

entrySetIconFromIconName Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: The position at which to set the icon
-> Maybe Text	`iconName`: An icon name, or `Nothing`
-> m ()

Sets the icon shown in the entry at the specified position from the current icon theme.

If the icon name isn’t known, a “broken image” icon will be displayed instead.

If iconName is Nothing, no icon will be shown in the specified position.

Since: 2.16

setIconFromPixbuf

entrySetIconFromPixbuf Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a, IsPixbuf b)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> Maybe b	`pixbuf`: A `Pixbuf`, or `Nothing`
-> m ()

Sets the icon shown in the specified position using a pixbuf.

If pixbuf is Nothing, no icon will be shown in the specified position.

Since: 2.16

setIconFromStock

entrySetIconFromStock Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> Maybe Text	`stockId`: The name of the stock item, or `Nothing`
-> m ()

Deprecated: (Since version 3.10)Use entrySetIconFromIconName instead.

Sets the icon shown in the entry at the specified position from a stock image.

If stockId is Nothing, no icon will be shown in the specified position.

Since: 2.16

setIconSensitive

entrySetIconSensitive Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: A `Entry`
-> EntryIconPosition	`iconPos`: Icon position
-> Bool	`sensitive`: Specifies whether the icon should appear sensitive or insensitive
-> m ()

Sets the sensitivity for the specified icon.

Since: 2.16

setIconTooltipMarkup

entrySetIconTooltipMarkup Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: the icon position
-> Maybe Text	`tooltip`: the contents of the tooltip for the icon, or `Nothing`
-> m ()

Sets tooltip as the contents of the tooltip for the icon at the specified position. tooltip is assumed to be marked up with the [Pango text markup language][PangoMarkupFormat].

Use Nothing for tooltip to remove an existing tooltip.

Since: 2.16

setIconTooltipText

entrySetIconTooltipText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> EntryIconPosition	`iconPos`: the icon position
-> Maybe Text	`tooltip`: the contents of the tooltip for the icon, or `Nothing`
-> m ()

Sets tooltip as the contents of the tooltip for the icon at the specified position.

Use Nothing for tooltip to remove an existing tooltip.

If you unset the widget tooltip via widgetSetTooltipText or widgetSetTooltipMarkup, this sets GtkWidget:has-tooltip to False, which suppresses icon tooltips too. You can resolve this by then calling widgetSetHasTooltip to set GtkWidget:has-tooltip back to True, or setting at least one non-empty tooltip on any icon achieves the same result.

Since: 2.16

setInnerBorder

entrySetInnerBorder Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Maybe Border	`border`: a `Border`, or `Nothing`
-> m ()

Deprecated: (Since version 3.4)Use the standard border and padding CSS properties (through objects like StyleContext and CssProvider); the value set with this function is ignored by Entry.

Sets entry’s inner-border property to border, or clears it if Nothing is passed. The inner-border is the area around the entry’s text, but inside its frame.

If set, this property overrides the inner-border style property. Overriding the style-provided border is useful when you want to do in-place editing of some text in a canvas or list widget, where pixel-exact positioning of the entry is important.

Since: 2.10

setInputHints

entrySetInputHints Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> [InputHints]	`hints`: the hints
-> m ()

Sets the Entry:input-hints property, which allows input methods to fine-tune their behaviour.

Since: 3.6

setInputPurpose

entrySetInputPurpose Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> InputPurpose	`purpose`: the purpose
-> m ()

Sets the Entry:input-purpose property which can be used by on-screen keyboards and other input methods to adjust their behaviour.

Since: 3.6

setInvisibleChar

entrySetInvisibleChar Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Char	`ch`: a Unicode character
-> m ()

Sets the character to use in place of the actual text when entrySetVisibility has been called to set text visibility to False. i.e. this is the character used in “password mode” to show the user how many characters have been typed. By default, GTK+ picks the best invisible char available in the current font. If you set the invisible char to 0, then the user will get no feedback at all; there will be no text on the screen as they type.

setMaxLength

entrySetMaxLength Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Int32	`max`: the maximum length of the entry, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536.
-> m ()

Sets the maximum allowed length of the contents of the widget. If the current contents are longer than the given length, then they will be truncated to fit.

This is equivalent to getting entry's EntryBuffer and calling entryBufferSetMaxLength on it. ]|

setMaxWidthChars

entrySetMaxWidthChars Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Int32	`nChars`: the new desired maximum width, in characters
-> m ()

Sets the desired maximum width in characters of entry.

Since: 3.12

setOverwriteMode

entrySetOverwriteMode Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Bool	`overwrite`: new value
-> m ()

Sets whether the text is overwritten when typing in the Entry.

Since: 2.14

setPlaceholderText

entrySetPlaceholderText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Maybe Text	`text`: a string to be displayed when `entry` is empty and unfocused, or `Nothing`
-> m ()

Sets text to be displayed in entry when it is empty and unfocused. This can be used to give a visual hint of the expected contents of the Entry.

Note that since the placeholder text gets removed when the entry received focus, using this feature is a bit problematic if the entry is given the initial focus in a window. Sometimes this can be worked around by delaying the initial focus setting until the first key event arrives.

Since: 3.2

setProgressFraction

entrySetProgressFraction Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Double	`fraction`: fraction of the task that’s been completed
-> m ()

Causes the entry’s progress indicator to “fill in” the given fraction of the bar. The fraction should be between 0.0 and 1.0, inclusive.

Since: 2.16

setProgressPulseStep

entrySetProgressPulseStep Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Double	`fraction`: fraction between 0.0 and 1.0
-> m ()

Sets the fraction of total entry width to move the progress bouncing block for each call to entryProgressPulse.

Since: 2.16

setTabs

entrySetTabs Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> TabArray	`tabs`: a `TabArray`
-> m ()

Sets a TabArray; the tabstops in the array are applied to the entry text.

Since: 3.10

setText

entrySetText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Text	`text`: the new text
-> m ()

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

See entryBufferSetText.

setVisibility

entrySetVisibility Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Bool	`visible`: `True` if the contents of the entry are displayed as plaintext
-> m ()

Sets whether the contents of the entry are visible or not. When visibility is set to False, characters are displayed as the invisible char, and will also appear that way when the text in the entry widget is copied elsewhere.

By default, GTK+ picks the best invisible character available in the current font, but it can be changed with entrySetInvisibleChar.

Note that you probably want to set Entry:input-purpose to InputPurposePassword or InputPurposePin to inform input methods about the purpose of this entry, in addition to setting visibility to False.

setWidthChars

entrySetWidthChars Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Int32	`nChars`: width in chars
-> m ()

Changes the size request of the entry 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 entry size.

textIndexToLayoutIndex

entryTextIndexToLayoutIndex Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> Int32	`textIndex`: byte index into the entry contents
-> m Int32	Returns: byte index into the entry layout text

Converts from a position in the entry contents (returned by entryGetText) to a position in the entry’s Layout (returned by entryGetLayout, with text retrieved via layoutGetText).

unsetInvisibleChar

entryUnsetInvisibleChar Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntry a)
=> a	`entry`: a `Entry`
-> m ()

Unsets the invisible char previously set with entrySetInvisibleChar. So that the default invisible char is used again.

Since: 2.16

Properties

activatesDefault

No description available in the introspection data.

constructEntryActivatesDefault :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #activatesDefault

setEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #activatesDefault := value ]

attributes

A list of Pango attributes to apply to the text of the entry.

This is mainly useful to change the size or weight of the text.

The 'GI.Pango.Structs.Attribute.Attribute'\'s startIndex and endIndex must refer to the EntryBuffer text, i.e. without the preedit string.

Since: 3.6

constructEntryAttributes :: IsEntry o => AttrList -> IO (GValueConstruct o) Source #

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

getEntryAttributes :: (MonadIO m, IsEntry o) => o -> m (Maybe AttrList) Source #

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

get entry #attributes

setEntryAttributes :: (MonadIO m, IsEntry o) => o -> AttrList -> m () Source #

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

set entry [ #attributes := value ]

buffer

No description available in the introspection data.

constructEntryBuffer :: (IsEntry o, IsEntryBuffer a) => a -> IO (GValueConstruct o) Source #

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

getEntryBuffer :: (MonadIO m, IsEntry o) => o -> m EntryBuffer Source #

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

get entry #buffer

setEntryBuffer :: (MonadIO m, IsEntry o, IsEntryBuffer a) => o -> a -> m () Source #

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

set entry [ #buffer := value ]

capsLockWarning

Whether password entries will show a warning when Caps Lock is on.

Note that the warning is shown using a secondary icon, and thus does not work if you are using the secondary icon position for some other purpose.

Since: 2.16

constructEntryCapsLockWarning :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “caps-lock-warning” property. When overloading is enabled, this is equivalent to

get entry #capsLockWarning

setEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “caps-lock-warning” property. When overloading is enabled, this is equivalent to

set entry [ #capsLockWarning := value ]

completion

The auxiliary completion object to use with the entry.

Since: 3.2

clearEntryCompletion :: (MonadIO m, IsEntry o) => o -> m () Source #

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

clear #completion

constructEntryCompletion :: (IsEntry o, IsEntryCompletion a) => a -> IO (GValueConstruct o) Source #

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

getEntryCompletion :: (MonadIO m, IsEntry o) => o -> m EntryCompletion Source #

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

get entry #completion

setEntryCompletion :: (MonadIO m, IsEntry o, IsEntryCompletion a) => o -> a -> m () Source #

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

set entry [ #completion := value ]

cursorPosition

No description available in the introspection data.

getEntryCursorPosition :: (MonadIO m, IsEntry o) => o -> m Int32 Source #

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

get entry #cursorPosition

editable

No description available in the introspection data.

constructEntryEditable :: IsEntry 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.

getEntryEditable :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #editable

setEntryEditable :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #editable := value ]

hasFrame

No description available in the introspection data.

constructEntryHasFrame :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryHasFrame :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #hasFrame

setEntryHasFrame :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #hasFrame := value ]

imModule

Which IM (input method) module should be used for this entry. See IMContext.

Setting this to a non-Nothing value overrides the system-wide IM module setting. See the GtkSettings Settings:gtk-im-module property.

Since: 2.16

clearEntryImModule :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “im-module” property to Nothing. When overloading is enabled, this is equivalent to

clear #imModule

constructEntryImModule :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntryImModule :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

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

get entry #imModule

setEntryImModule :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

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

set entry [ #imModule := value ]

innerBorder

Sets the text area's border between the text and the frame.

Since: 2.10

clearEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “inner-border” property to Nothing. When overloading is enabled, this is equivalent to

clear #innerBorder

constructEntryInnerBorder :: IsEntry o => Border -> IO (GValueConstruct o) Source #

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

getEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m (Maybe Border) Source #

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

get entry #innerBorder

setEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> Border -> m () Source #

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

set entry [ #innerBorder := value ]

inputHints

Additional hints (beyond Entry:input-purpose) that allow input methods to fine-tune their behaviour.

Since: 3.6

constructEntryInputHints :: IsEntry o => [InputHints] -> IO (GValueConstruct o) Source #

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

getEntryInputHints :: (MonadIO m, IsEntry o) => o -> m [InputHints] Source #

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

get entry #inputHints

setEntryInputHints :: (MonadIO m, IsEntry o) => o -> [InputHints] -> m () Source #

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

set entry [ #inputHints := value ]

inputPurpose

The purpose of this text field.

This property can be used by on-screen keyboards and other input methods to adjust their behaviour.

Note that setting the purpose to InputPurposePassword or InputPurposePin is independent from setting Entry:visibility.

Since: 3.6

constructEntryInputPurpose :: IsEntry o => InputPurpose -> IO (GValueConstruct o) Source #

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

getEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> m InputPurpose Source #

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

get entry #inputPurpose

setEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> InputPurpose -> m () Source #

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

set entry [ #inputPurpose := value ]

invisibleChar

The invisible character is used when masking entry contents (in \"password mode\")"). When it is not explicitly set with the Entry:invisible-char property, GTK+ determines the character to use from a list of possible candidates, depending on availability in the current font.

This style property allows the theme to prepend a character to the list of candidates.

Since: 2.18

constructEntryInvisibleChar :: IsEntry o => Word32 -> IO (GValueConstruct o) Source #

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

getEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> m Word32 Source #

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

get entry #invisibleChar

setEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> Word32 -> m () Source #

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

set entry [ #invisibleChar := value ]

invisibleCharSet

Whether the invisible char has been set for the Entry.

Since: 2.16

constructEntryInvisibleCharSet :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “invisible-char-set” property. When overloading is enabled, this is equivalent to

get entry #invisibleCharSet

setEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “invisible-char-set” property. When overloading is enabled, this is equivalent to

set entry [ #invisibleCharSet := value ]

maxLength

No description available in the introspection data.

constructEntryMaxLength :: IsEntry o => Int32 -> IO (GValueConstruct o) Source #

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

getEntryMaxLength :: (MonadIO m, IsEntry o) => o -> m Int32 Source #

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

get entry #maxLength

setEntryMaxLength :: (MonadIO m, IsEntry o) => o -> Int32 -> m () Source #

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

set entry [ #maxLength := value ]

maxWidthChars

The desired maximum width of the entry, in characters. If this property is set to -1, the width will be calculated automatically.

Since: 3.12

constructEntryMaxWidthChars :: IsEntry 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.

getEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32 Source #

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

get entry #maxWidthChars

setEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m () Source #

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

set entry [ #maxWidthChars := value ]

overwriteMode

If text is overwritten when typing in the Entry.

Since: 2.14

constructEntryOverwriteMode :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #overwriteMode

setEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #overwriteMode := value ]

placeholderText

The text that will be displayed in the Entry when it is empty and unfocused.

Since: 3.2

clearEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m () Source #

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

clear #placeholderText

constructEntryPlaceholderText :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m Text Source #

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

get entry #placeholderText

setEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

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

set entry [ #placeholderText := value ]

populateAll

If :populate-all is True, the Entry::populate-popup signal is also emitted for touch popups.

Since: 3.8

constructEntryPopulateAll :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #populateAll

setEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #populateAll := value ]

primaryIconActivatable

Whether the primary icon is activatable.

GTK+ emits the Entry::icon-press and Entry::icon-release signals only on sensitive, activatable icons.

Sensitive, but non-activatable icons can be used for purely informational purposes.

Since: 2.16

constructEntryPrimaryIconActivatable :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “primary-icon-activatable” property. When overloading is enabled, this is equivalent to

get entry #primaryIconActivatable

setEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “primary-icon-activatable” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconActivatable := value ]

primaryIconGicon

The Icon to use for the primary icon for the entry.

Since: 2.16

clearEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “primary-icon-gicon” property to Nothing. When overloading is enabled, this is equivalent to

clear #primaryIconGicon

constructEntryPrimaryIconGicon :: (IsEntry o, IsIcon a) => a -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon) Source #

Get the value of the “primary-icon-gicon” property. When overloading is enabled, this is equivalent to

get entry #primaryIconGicon

setEntryPrimaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m () Source #

Set the value of the “primary-icon-gicon” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconGicon := value ]

primaryIconName

The icon name to use for the primary icon for the entry.

Since: 2.16

clearEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “primary-icon-name” property to Nothing. When overloading is enabled, this is equivalent to

clear #primaryIconName

constructEntryPrimaryIconName :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

Get the value of the “primary-icon-name” property. When overloading is enabled, this is equivalent to

get entry #primaryIconName

setEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

Set the value of the “primary-icon-name” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconName := value ]

primaryIconPixbuf

A pixbuf to use as the primary icon for the entry.

Since: 2.16

clearEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “primary-icon-pixbuf” property to Nothing. When overloading is enabled, this is equivalent to

clear #primaryIconPixbuf

constructEntryPrimaryIconPixbuf :: (IsEntry o, IsPixbuf a) => a -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf) Source #

Get the value of the “primary-icon-pixbuf” property. When overloading is enabled, this is equivalent to

get entry #primaryIconPixbuf

setEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m () Source #

Set the value of the “primary-icon-pixbuf” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconPixbuf := value ]

primaryIconSensitive

Whether the primary icon is sensitive.

An insensitive icon appears grayed out. GTK+ does not emit the Entry::icon-press and Entry::icon-release signals and does not allow DND from insensitive icons.

An icon should be set insensitive if the action that would trigger when clicked is currently not available.

Since: 2.16

constructEntryPrimaryIconSensitive :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “primary-icon-sensitive” property. When overloading is enabled, this is equivalent to

get entry #primaryIconSensitive

setEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “primary-icon-sensitive” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconSensitive := value ]

primaryIconStock

The stock id to use for the primary icon for the entry.

Since: 2.16

clearEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “primary-icon-stock” property to Nothing. When overloading is enabled, this is equivalent to

clear #primaryIconStock

constructEntryPrimaryIconStock :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

Get the value of the “primary-icon-stock” property. When overloading is enabled, this is equivalent to

get entry #primaryIconStock

setEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

Set the value of the “primary-icon-stock” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconStock := value ]

primaryIconStorageType

The representation which is used for the primary icon of the entry.

Since: 2.16

getEntryPrimaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType Source #

Get the value of the “primary-icon-storage-type” property. When overloading is enabled, this is equivalent to

get entry #primaryIconStorageType

primaryIconTooltipMarkup

The contents of the tooltip on the primary icon, which is marked up with the [Pango text markup language][PangoMarkupFormat].

Also see entrySetIconTooltipMarkup.

Since: 2.16

clearEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “primary-icon-tooltip-markup” property to Nothing. When overloading is enabled, this is equivalent to

clear #primaryIconTooltipMarkup

constructEntryPrimaryIconTooltipMarkup :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

Get the value of the “primary-icon-tooltip-markup” property. When overloading is enabled, this is equivalent to

get entry #primaryIconTooltipMarkup

setEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

Set the value of the “primary-icon-tooltip-markup” property. When overloading is enabled, this is equivalent to

set entry [ #primaryIconTooltipMarkup := value ]

primaryIconTooltipText

The contents of the tooltip on the primary icon.

Also see entrySetIconTooltipText.

Since: 2.16

clearEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “primary-icon-tooltip-text” property to Nothing. When overloading is enabled, this is equivalent to

clear #primaryIconTooltipText

constructEntryPrimaryIconTooltipText :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

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

get entry #primaryIconTooltipText

setEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

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

set entry [ #primaryIconTooltipText := value ]

progressFraction

The current fraction of the task that's been completed.

Since: 2.16

constructEntryProgressFraction :: IsEntry o => Double -> IO (GValueConstruct o) Source #

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

getEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> m Double Source #

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

get entry #progressFraction

setEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> Double -> m () Source #

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

set entry [ #progressFraction := value ]

progressPulseStep

The fraction of total entry width to move the progress bouncing block for each call to entryProgressPulse.

Since: 2.16

constructEntryProgressPulseStep :: IsEntry o => Double -> IO (GValueConstruct o) Source #

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

getEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> m Double Source #

Get the value of the “progress-pulse-step” property. When overloading is enabled, this is equivalent to

get entry #progressPulseStep

setEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> Double -> m () Source #

Set the value of the “progress-pulse-step” property. When overloading is enabled, this is equivalent to

set entry [ #progressPulseStep := value ]

scrollOffset

No description available in the introspection data.

getEntryScrollOffset :: (MonadIO m, IsEntry o) => o -> m Int32 Source #

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

get entry #scrollOffset

secondaryIconActivatable

Whether the secondary icon is activatable.

GTK+ emits the Entry::icon-press and Entry::icon-release signals only on sensitive, activatable icons.

Sensitive, but non-activatable icons can be used for purely informational purposes.

Since: 2.16

constructEntrySecondaryIconActivatable :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “secondary-icon-activatable” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconActivatable

setEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “secondary-icon-activatable” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconActivatable := value ]

secondaryIconGicon

The Icon to use for the secondary icon for the entry.

Since: 2.16

clearEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “secondary-icon-gicon” property to Nothing. When overloading is enabled, this is equivalent to

clear #secondaryIconGicon

constructEntrySecondaryIconGicon :: (IsEntry o, IsIcon a) => a -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon) Source #

Get the value of the “secondary-icon-gicon” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconGicon

setEntrySecondaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m () Source #

Set the value of the “secondary-icon-gicon” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconGicon := value ]

secondaryIconName

The icon name to use for the secondary icon for the entry.

Since: 2.16

clearEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “secondary-icon-name” property to Nothing. When overloading is enabled, this is equivalent to

clear #secondaryIconName

constructEntrySecondaryIconName :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

Get the value of the “secondary-icon-name” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconName

setEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

Set the value of the “secondary-icon-name” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconName := value ]

secondaryIconPixbuf

An pixbuf to use as the secondary icon for the entry.

Since: 2.16

clearEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “secondary-icon-pixbuf” property to Nothing. When overloading is enabled, this is equivalent to

clear #secondaryIconPixbuf

constructEntrySecondaryIconPixbuf :: (IsEntry o, IsPixbuf a) => a -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf) Source #

Get the value of the “secondary-icon-pixbuf” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconPixbuf

setEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m () Source #

Set the value of the “secondary-icon-pixbuf” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconPixbuf := value ]

secondaryIconSensitive

Whether the secondary icon is sensitive.

An insensitive icon appears grayed out. GTK+ does not emit the Entry::icon-press and Entry::icon-release signals and does not allow DND from insensitive icons.

An icon should be set insensitive if the action that would trigger when clicked is currently not available.

Since: 2.16

constructEntrySecondaryIconSensitive :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “secondary-icon-sensitive” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconSensitive

setEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “secondary-icon-sensitive” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconSensitive := value ]

secondaryIconStock

The stock id to use for the secondary icon for the entry.

Since: 2.16

clearEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “secondary-icon-stock” property to Nothing. When overloading is enabled, this is equivalent to

clear #secondaryIconStock

constructEntrySecondaryIconStock :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

Get the value of the “secondary-icon-stock” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconStock

setEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

Set the value of the “secondary-icon-stock” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconStock := value ]

secondaryIconStorageType

The representation which is used for the secondary icon of the entry.

Since: 2.16

getEntrySecondaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType Source #

Get the value of the “secondary-icon-storage-type” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconStorageType

secondaryIconTooltipMarkup

The contents of the tooltip on the secondary icon, which is marked up with the [Pango text markup language][PangoMarkupFormat].

Also see entrySetIconTooltipMarkup.

Since: 2.16

clearEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “secondary-icon-tooltip-markup” property to Nothing. When overloading is enabled, this is equivalent to

clear #secondaryIconTooltipMarkup

constructEntrySecondaryIconTooltipMarkup :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

Get the value of the “secondary-icon-tooltip-markup” property. When overloading is enabled, this is equivalent to

get entry #secondaryIconTooltipMarkup

setEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

Set the value of the “secondary-icon-tooltip-markup” property. When overloading is enabled, this is equivalent to

set entry [ #secondaryIconTooltipMarkup := value ]

secondaryIconTooltipText

The contents of the tooltip on the secondary icon.

Also see entrySetIconTooltipText.

Since: 2.16

clearEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m () Source #

Set the value of the “secondary-icon-tooltip-text” property to Nothing. When overloading is enabled, this is equivalent to

clear #secondaryIconTooltipText

constructEntrySecondaryIconTooltipText :: IsEntry o => Text -> IO (GValueConstruct o) Source #

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

getEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text) Source #

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

get entry #secondaryIconTooltipText

setEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

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

set entry [ #secondaryIconTooltipText := value ]

selectionBound

No description available in the introspection data.

getEntrySelectionBound :: (MonadIO m, IsEntry o) => o -> m Int32 Source #

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

get entry #selectionBound

shadowType

Which kind of shadow to draw around the entry when Entry:has-frame is set to True.

Since: 2.12

constructEntryShadowType :: IsEntry o => ShadowType -> IO (GValueConstruct o) Source #

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

getEntryShadowType :: (MonadIO m, IsEntry o) => o -> m ShadowType Source #

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

get entry #shadowType

setEntryShadowType :: (MonadIO m, IsEntry o) => o -> ShadowType -> m () Source #

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

set entry [ #shadowType := value ]

showEmojiIcon

No description available in the introspection data.

constructEntryShowEmojiIcon :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> m Bool Source #

Get the value of the “show-emoji-icon” property. When overloading is enabled, this is equivalent to

get entry #showEmojiIcon

setEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

Set the value of the “show-emoji-icon” property. When overloading is enabled, this is equivalent to

set entry [ #showEmojiIcon := value ]

tabs

No description available in the introspection data.

constructEntryTabs :: IsEntry o => TabArray -> IO (GValueConstruct o) Source #

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

getEntryTabs :: (MonadIO m, IsEntry o) => o -> m (Maybe TabArray) Source #

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

get entry #tabs

setEntryTabs :: (MonadIO m, IsEntry o) => o -> TabArray -> m () Source #

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

set entry [ #tabs := value ]

text

No description available in the introspection data.

constructEntryText :: IsEntry 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.

getEntryText :: (MonadIO m, IsEntry o) => o -> m Text Source #

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

get entry #text

setEntryText :: (MonadIO m, IsEntry o) => o -> Text -> m () Source #

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

set entry [ #text := value ]

textLength

The length of the text in the Entry.

Since: 2.14

getEntryTextLength :: (MonadIO m, IsEntry o) => o -> m Word32 Source #

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

get entry #textLength

truncateMultiline

When True, pasted multi-line text is truncated to the first line.

Since: 2.10

constructEntryTruncateMultiline :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #truncateMultiline

setEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #truncateMultiline := value ]

visibility

No description available in the introspection data.

constructEntryVisibility :: IsEntry o => Bool -> IO (GValueConstruct o) Source #

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

getEntryVisibility :: (MonadIO m, IsEntry o) => o -> m Bool Source #

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

get entry #visibility

setEntryVisibility :: (MonadIO m, IsEntry o) => o -> Bool -> m () Source #

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

set entry [ #visibility := value ]

widthChars

No description available in the introspection data.

constructEntryWidthChars :: IsEntry 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.

getEntryWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32 Source #

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

get entry #widthChars

setEntryWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m () Source #

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

set entry [ #widthChars := value ]

xalign

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

Since: 2.4

constructEntryXalign :: IsEntry 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.

getEntryXalign :: (MonadIO m, IsEntry o) => o -> m Float Source #

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

get entry #xalign

setEntryXalign :: (MonadIO m, IsEntry o) => o -> Float -> m () Source #

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

set entry [ #xalign := value ]

Signals

activate

type C_EntryActivateCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryActivateCallback = IO () Source #

The ::activate signal is emitted when the user hits the Enter key.

While this signal is used as a [keybinding signal][GtkBindingSignal], it is also commonly used by applications to intercept activation of entries.

The default bindings for this signal are all forms of the Enter key.

afterEntryActivate :: (IsEntry a, MonadIO m) => a -> EntryActivateCallback -> m SignalHandlerId Source #

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

after entry #activate callback

genClosure_EntryActivate :: EntryActivateCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryActivateCallback :: C_EntryActivateCallback -> IO (FunPtr C_EntryActivateCallback) Source #

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

noEntryActivateCallback :: Maybe EntryActivateCallback Source #

A convenience synonym for Nothing :: Maybe EntryActivateCallback.

onEntryActivate :: (IsEntry a, MonadIO m) => a -> EntryActivateCallback -> m SignalHandlerId Source #

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

on entry #activate callback

wrap_EntryActivateCallback :: EntryActivateCallback -> C_EntryActivateCallback Source #

Wrap a EntryActivateCallback into a C_EntryActivateCallback.

backspace

type C_EntryBackspaceCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryBackspaceCallback = IO () Source #

The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it.

The default bindings for this signal are Backspace and Shift-Backspace.

afterEntryBackspace :: (IsEntry a, MonadIO m) => a -> EntryBackspaceCallback -> m SignalHandlerId Source #

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

after entry #backspace callback

genClosure_EntryBackspace :: EntryBackspaceCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryBackspaceCallback :: C_EntryBackspaceCallback -> IO (FunPtr C_EntryBackspaceCallback) Source #

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

noEntryBackspaceCallback :: Maybe EntryBackspaceCallback Source #

A convenience synonym for Nothing :: Maybe EntryBackspaceCallback.

onEntryBackspace :: (IsEntry a, MonadIO m) => a -> EntryBackspaceCallback -> m SignalHandlerId Source #

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

on entry #backspace callback

wrap_EntryBackspaceCallback :: EntryBackspaceCallback -> C_EntryBackspaceCallback Source #

Wrap a EntryBackspaceCallback into a C_EntryBackspaceCallback.

copyClipboard

type C_EntryCopyClipboardCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryCopyClipboardCallback = IO () Source #

The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard.

The default bindings for this signal are Ctrl-c and Ctrl-Insert.

afterEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> EntryCopyClipboardCallback -> m SignalHandlerId Source #

Connect a signal handler for the “copy-clipboard” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #copyClipboard callback

genClosure_EntryCopyClipboard :: EntryCopyClipboardCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryCopyClipboardCallback :: C_EntryCopyClipboardCallback -> IO (FunPtr C_EntryCopyClipboardCallback) Source #

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

noEntryCopyClipboardCallback :: Maybe EntryCopyClipboardCallback Source #

A convenience synonym for Nothing :: Maybe EntryCopyClipboardCallback.

onEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> EntryCopyClipboardCallback -> m SignalHandlerId Source #

Connect a signal handler for the “copy-clipboard” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #copyClipboard callback

wrap_EntryCopyClipboardCallback :: EntryCopyClipboardCallback -> C_EntryCopyClipboardCallback Source #

Wrap a EntryCopyClipboardCallback into a C_EntryCopyClipboardCallback.

cutClipboard

type C_EntryCutClipboardCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryCutClipboardCallback = IO () Source #

The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard.

The default bindings for this signal are Ctrl-x and Shift-Delete.

afterEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> EntryCutClipboardCallback -> m SignalHandlerId Source #

Connect a signal handler for the “cut-clipboard” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #cutClipboard callback

genClosure_EntryCutClipboard :: EntryCutClipboardCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryCutClipboardCallback :: C_EntryCutClipboardCallback -> IO (FunPtr C_EntryCutClipboardCallback) Source #

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

noEntryCutClipboardCallback :: Maybe EntryCutClipboardCallback Source #

A convenience synonym for Nothing :: Maybe EntryCutClipboardCallback.

onEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> EntryCutClipboardCallback -> m SignalHandlerId Source #

Connect a signal handler for the “cut-clipboard” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #cutClipboard callback

wrap_EntryCutClipboardCallback :: EntryCutClipboardCallback -> C_EntryCutClipboardCallback Source #

Wrap a EntryCutClipboardCallback into a C_EntryCutClipboardCallback.

deleteFromCursor

type C_EntryDeleteFromCursorCallback = Ptr () -> CUInt -> Int32 -> Ptr () -> IO () Source #

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

type EntryDeleteFromCursorCallback Source #

Arguments

= DeleteType	`type`: the granularity of the deletion, as a `DeleteType`
-> Int32	`count`: the number of `type` units to delete
-> IO ()

The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion.

If the type is DeleteTypeChars, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters.

The default bindings for this signal are Delete for deleting a character and Ctrl-Delete for deleting a word.

afterEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> EntryDeleteFromCursorCallback -> m SignalHandlerId Source #

Connect a signal handler for the “delete-from-cursor” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #deleteFromCursor callback

genClosure_EntryDeleteFromCursor :: EntryDeleteFromCursorCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryDeleteFromCursorCallback :: C_EntryDeleteFromCursorCallback -> IO (FunPtr C_EntryDeleteFromCursorCallback) Source #

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

noEntryDeleteFromCursorCallback :: Maybe EntryDeleteFromCursorCallback Source #

A convenience synonym for Nothing :: Maybe EntryDeleteFromCursorCallback.

onEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> EntryDeleteFromCursorCallback -> m SignalHandlerId Source #

Connect a signal handler for the “delete-from-cursor” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #deleteFromCursor callback

wrap_EntryDeleteFromCursorCallback :: EntryDeleteFromCursorCallback -> C_EntryDeleteFromCursorCallback Source #

Wrap a EntryDeleteFromCursorCallback into a C_EntryDeleteFromCursorCallback.

iconPress

type C_EntryIconPressCallback = Ptr () -> CUInt -> Ptr EventButton -> Ptr () -> IO () Source #

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

type EntryIconPressCallback Source #

Arguments

= EntryIconPosition	`iconPos`: The position of the clicked icon
-> EventButton	`event`: the button press event
-> IO ()

The ::icon-press signal is emitted when an activatable icon is clicked.

Since: 2.16

afterEntryIconPress :: (IsEntry a, MonadIO m) => a -> EntryIconPressCallback -> m SignalHandlerId Source #

Connect a signal handler for the “icon-press” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #iconPress callback

genClosure_EntryIconPress :: EntryIconPressCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryIconPressCallback :: C_EntryIconPressCallback -> IO (FunPtr C_EntryIconPressCallback) Source #

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

noEntryIconPressCallback :: Maybe EntryIconPressCallback Source #

A convenience synonym for Nothing :: Maybe EntryIconPressCallback.

onEntryIconPress :: (IsEntry a, MonadIO m) => a -> EntryIconPressCallback -> m SignalHandlerId Source #

Connect a signal handler for the “icon-press” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #iconPress callback

wrap_EntryIconPressCallback :: EntryIconPressCallback -> C_EntryIconPressCallback Source #

Wrap a EntryIconPressCallback into a C_EntryIconPressCallback.

iconRelease

type C_EntryIconReleaseCallback = Ptr () -> CUInt -> Ptr EventButton -> Ptr () -> IO () Source #

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

type EntryIconReleaseCallback Source #

Arguments

= EntryIconPosition	`iconPos`: The position of the clicked icon
-> EventButton	`event`: the button release event
-> IO ()

The ::icon-release signal is emitted on the button release from a mouse click over an activatable icon.

Since: 2.16

afterEntryIconRelease :: (IsEntry a, MonadIO m) => a -> EntryIconReleaseCallback -> m SignalHandlerId Source #

Connect a signal handler for the “icon-release” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #iconRelease callback

genClosure_EntryIconRelease :: EntryIconReleaseCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryIconReleaseCallback :: C_EntryIconReleaseCallback -> IO (FunPtr C_EntryIconReleaseCallback) Source #

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

noEntryIconReleaseCallback :: Maybe EntryIconReleaseCallback Source #

A convenience synonym for Nothing :: Maybe EntryIconReleaseCallback.

onEntryIconRelease :: (IsEntry a, MonadIO m) => a -> EntryIconReleaseCallback -> m SignalHandlerId Source #

Connect a signal handler for the “icon-release” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #iconRelease callback

wrap_EntryIconReleaseCallback :: EntryIconReleaseCallback -> C_EntryIconReleaseCallback Source #

Wrap a EntryIconReleaseCallback into a C_EntryIconReleaseCallback.

insertAtCursor

type C_EntryInsertAtCursorCallback = Ptr () -> CString -> Ptr () -> IO () Source #

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

type EntryInsertAtCursorCallback Source #

Arguments

= Text	`string`: the string to insert
-> IO ()

The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor.

This signal has no default bindings.

afterEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> EntryInsertAtCursorCallback -> m SignalHandlerId Source #

Connect a signal handler for the “insert-at-cursor” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #insertAtCursor callback

genClosure_EntryInsertAtCursor :: EntryInsertAtCursorCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryInsertAtCursorCallback :: C_EntryInsertAtCursorCallback -> IO (FunPtr C_EntryInsertAtCursorCallback) Source #

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

noEntryInsertAtCursorCallback :: Maybe EntryInsertAtCursorCallback Source #

A convenience synonym for Nothing :: Maybe EntryInsertAtCursorCallback.

onEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> EntryInsertAtCursorCallback -> m SignalHandlerId Source #

Connect a signal handler for the “insert-at-cursor” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #insertAtCursor callback

wrap_EntryInsertAtCursorCallback :: EntryInsertAtCursorCallback -> C_EntryInsertAtCursorCallback Source #

Wrap a EntryInsertAtCursorCallback into a C_EntryInsertAtCursorCallback.

insertEmoji

type C_EntryInsertEmojiCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryInsertEmojiCallback = IO () Source #

The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the entry.

The default bindings for this signal are Ctrl-. and Ctrl-;

Since: 3.22.27

afterEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> EntryInsertEmojiCallback -> m SignalHandlerId Source #

Connect a signal handler for the “insert-emoji” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #insertEmoji callback

genClosure_EntryInsertEmoji :: EntryInsertEmojiCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryInsertEmojiCallback :: C_EntryInsertEmojiCallback -> IO (FunPtr C_EntryInsertEmojiCallback) Source #

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

noEntryInsertEmojiCallback :: Maybe EntryInsertEmojiCallback Source #

A convenience synonym for Nothing :: Maybe EntryInsertEmojiCallback.

onEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> EntryInsertEmojiCallback -> m SignalHandlerId Source #

Connect a signal handler for the “insert-emoji” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #insertEmoji callback

wrap_EntryInsertEmojiCallback :: EntryInsertEmojiCallback -> C_EntryInsertEmojiCallback Source #

Wrap a EntryInsertEmojiCallback into a C_EntryInsertEmojiCallback.

moveCursor

type C_EntryMoveCursorCallback = Ptr () -> CUInt -> Int32 -> CInt -> Ptr () -> IO () Source #

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

type EntryMoveCursorCallback Source #

Arguments

= MovementStep	`step`: the granularity of the move, as a `MovementStep`
-> Int32	`count`: the number of `step` units to move
-> Bool	`extendSelection`: `True` if the move should extend the selection
-> IO ()

The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in entry, this signal causes the viewport to be moved instead.

Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically.

The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here.

Arrow keys move by individual characters/lines
Ctrl-arrow key combinations move by words/paragraphs
Home/End keys move to the ends of the buffer

afterEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> EntryMoveCursorCallback -> m SignalHandlerId Source #

Connect a signal handler for the “move-cursor” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #moveCursor callback

genClosure_EntryMoveCursor :: EntryMoveCursorCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryMoveCursorCallback :: C_EntryMoveCursorCallback -> IO (FunPtr C_EntryMoveCursorCallback) Source #

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

noEntryMoveCursorCallback :: Maybe EntryMoveCursorCallback Source #

A convenience synonym for Nothing :: Maybe EntryMoveCursorCallback.

onEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> EntryMoveCursorCallback -> m SignalHandlerId Source #

Connect a signal handler for the “move-cursor” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #moveCursor callback

wrap_EntryMoveCursorCallback :: EntryMoveCursorCallback -> C_EntryMoveCursorCallback Source #

Wrap a EntryMoveCursorCallback into a C_EntryMoveCursorCallback.

pasteClipboard

type C_EntryPasteClipboardCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryPasteClipboardCallback = IO () Source #

The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view.

The default bindings for this signal are Ctrl-v and Shift-Insert.

afterEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> EntryPasteClipboardCallback -> m SignalHandlerId Source #

Connect a signal handler for the “paste-clipboard” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #pasteClipboard callback

genClosure_EntryPasteClipboard :: EntryPasteClipboardCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryPasteClipboardCallback :: C_EntryPasteClipboardCallback -> IO (FunPtr C_EntryPasteClipboardCallback) Source #

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

noEntryPasteClipboardCallback :: Maybe EntryPasteClipboardCallback Source #

A convenience synonym for Nothing :: Maybe EntryPasteClipboardCallback.

onEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> EntryPasteClipboardCallback -> m SignalHandlerId Source #

Connect a signal handler for the “paste-clipboard” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #pasteClipboard callback

wrap_EntryPasteClipboardCallback :: EntryPasteClipboardCallback -> C_EntryPasteClipboardCallback Source #

Wrap a EntryPasteClipboardCallback into a C_EntryPasteClipboardCallback.

populatePopup

type C_EntryPopulatePopupCallback = Ptr () -> Ptr Widget -> Ptr () -> IO () Source #

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

type EntryPopulatePopupCallback Source #

Arguments

= Widget	`widget`: the container that is being populated
-> IO ()

The ::populate-popup signal gets emitted before showing the context menu of the entry.

If you need to add items to the context menu, connect to this signal and append your items to the widget, which will be a Menu in this case.

If Entry:populate-all is True, this signal will also be emitted to populate touch popups. In this case, widget will be a different container, e.g. a Toolbar. The signal handler should not make assumptions about the type of widget.

afterEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> EntryPopulatePopupCallback -> m SignalHandlerId Source #

Connect a signal handler for the “populate-popup” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #populatePopup callback

genClosure_EntryPopulatePopup :: EntryPopulatePopupCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryPopulatePopupCallback :: C_EntryPopulatePopupCallback -> IO (FunPtr C_EntryPopulatePopupCallback) Source #

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

noEntryPopulatePopupCallback :: Maybe EntryPopulatePopupCallback Source #

A convenience synonym for Nothing :: Maybe EntryPopulatePopupCallback.

onEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> EntryPopulatePopupCallback -> m SignalHandlerId Source #

Connect a signal handler for the “populate-popup” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #populatePopup callback

wrap_EntryPopulatePopupCallback :: EntryPopulatePopupCallback -> C_EntryPopulatePopupCallback Source #

Wrap a EntryPopulatePopupCallback into a C_EntryPopulatePopupCallback.

preeditChanged

type C_EntryPreeditChangedCallback = Ptr () -> CString -> Ptr () -> IO () Source #

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

type EntryPreeditChangedCallback Source #

Arguments

= Text	`preedit`: the current preedit string
-> IO ()

If an input method is used, the typed text will not immediately be committed to the buffer. So if you are interested in the text, connect to this signal.

Since: 2.20

afterEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> EntryPreeditChangedCallback -> m SignalHandlerId Source #

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

after entry #preeditChanged callback

genClosure_EntryPreeditChanged :: EntryPreeditChangedCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryPreeditChangedCallback :: C_EntryPreeditChangedCallback -> IO (FunPtr C_EntryPreeditChangedCallback) Source #

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

noEntryPreeditChangedCallback :: Maybe EntryPreeditChangedCallback Source #

A convenience synonym for Nothing :: Maybe EntryPreeditChangedCallback.

onEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> EntryPreeditChangedCallback -> m SignalHandlerId Source #

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

on entry #preeditChanged callback

wrap_EntryPreeditChangedCallback :: EntryPreeditChangedCallback -> C_EntryPreeditChangedCallback Source #

Wrap a EntryPreeditChangedCallback into a C_EntryPreeditChangedCallback.

toggleOverwrite

type C_EntryToggleOverwriteCallback = Ptr () -> Ptr () -> IO () Source #

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

type EntryToggleOverwriteCallback = IO () Source #

The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the entry.

The default bindings for this signal is Insert.

afterEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> EntryToggleOverwriteCallback -> m SignalHandlerId Source #

Connect a signal handler for the “toggle-overwrite” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after entry #toggleOverwrite callback

genClosure_EntryToggleOverwrite :: EntryToggleOverwriteCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_EntryToggleOverwriteCallback :: C_EntryToggleOverwriteCallback -> IO (FunPtr C_EntryToggleOverwriteCallback) Source #

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

noEntryToggleOverwriteCallback :: Maybe EntryToggleOverwriteCallback Source #

A convenience synonym for Nothing :: Maybe EntryToggleOverwriteCallback.

onEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> EntryToggleOverwriteCallback -> m SignalHandlerId Source #

Connect a signal handler for the “toggle-overwrite” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on entry #toggleOverwrite callback

wrap_EntryToggleOverwriteCallback :: EntryToggleOverwriteCallback -> C_EntryToggleOverwriteCallback Source #

Wrap a EntryToggleOverwriteCallback into a C_EntryToggleOverwriteCallback.