{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) The 'GI.Gtk.Interfaces.Editable.Editable' interface is an interface which should be implemented by text editing widgets, such as 'GI.Gtk.Objects.Entry.Entry' and 'GI.Gtk.Objects.SpinButton.SpinButton'. It contains functions for generically manipulating an editable widget, a large number of action signals used for key bindings, and several signals that an application can connect to to modify the behavior of a widget. As an example of the latter usage, by connecting the following handler to 'GI.Gtk.Interfaces.Editable.Editable'::@/insert-text/@, an application can convert all entry into a widget into uppercase. == Forcing entry to uppercase. === /C code/ > >#include ; > >void >insert_text_handler (GtkEditable *editable, > const gchar *text, > gint length, > gint *position, > gpointer data) >{ > gchar *result = g_utf8_strup (text, length); > > g_signal_handlers_block_by_func (editable, > (gpointer) insert_text_handler, data); > gtk_editable_insert_text (editable, result, length, position); > g_signal_handlers_unblock_by_func (editable, > (gpointer) insert_text_handler, data); > > g_signal_stop_emission_by_name (editable, "insert_text"); > > g_free (result); >} -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Interfaces.Editable ( -- * Exported types Editable(..) , noEditable , IsEditable , toEditable , -- * Methods -- ** copyClipboard #method:copyClipboard# #if ENABLE_OVERLOADING EditableCopyClipboardMethodInfo , #endif editableCopyClipboard , -- ** cutClipboard #method:cutClipboard# #if ENABLE_OVERLOADING EditableCutClipboardMethodInfo , #endif editableCutClipboard , -- ** deleteSelection #method:deleteSelection# #if ENABLE_OVERLOADING EditableDeleteSelectionMethodInfo , #endif editableDeleteSelection , -- ** deleteText #method:deleteText# #if ENABLE_OVERLOADING EditableDeleteTextMethodInfo , #endif editableDeleteText , -- ** getChars #method:getChars# #if ENABLE_OVERLOADING EditableGetCharsMethodInfo , #endif editableGetChars , -- ** getEditable #method:getEditable# #if ENABLE_OVERLOADING EditableGetEditableMethodInfo , #endif editableGetEditable , -- ** getPosition #method:getPosition# #if ENABLE_OVERLOADING EditableGetPositionMethodInfo , #endif editableGetPosition , -- ** getSelectionBounds #method:getSelectionBounds# #if ENABLE_OVERLOADING EditableGetSelectionBoundsMethodInfo , #endif editableGetSelectionBounds , -- ** insertText #method:insertText# #if ENABLE_OVERLOADING EditableInsertTextMethodInfo , #endif editableInsertText , -- ** pasteClipboard #method:pasteClipboard# #if ENABLE_OVERLOADING EditablePasteClipboardMethodInfo , #endif editablePasteClipboard , -- ** selectRegion #method:selectRegion# #if ENABLE_OVERLOADING EditableSelectRegionMethodInfo , #endif editableSelectRegion , -- ** setEditable #method:setEditable# #if ENABLE_OVERLOADING EditableSetEditableMethodInfo , #endif editableSetEditable , -- ** setPosition #method:setPosition# #if ENABLE_OVERLOADING EditableSetPositionMethodInfo , #endif editableSetPosition , -- * Signals -- ** changed #signal:changed# C_EditableChangedCallback , EditableChangedCallback , #if ENABLE_OVERLOADING EditableChangedSignalInfo , #endif afterEditableChanged , genClosure_EditableChanged , mk_EditableChangedCallback , noEditableChangedCallback , onEditableChanged , wrap_EditableChangedCallback , -- ** deleteText #signal:deleteText# C_EditableDeleteTextCallback , EditableDeleteTextCallback , #if ENABLE_OVERLOADING EditableDeleteTextSignalInfo , #endif afterEditableDeleteText , genClosure_EditableDeleteText , mk_EditableDeleteTextCallback , noEditableDeleteTextCallback , onEditableDeleteText , wrap_EditableDeleteTextCallback , -- ** insertText #signal:insertText# C_EditableInsertTextCallback , EditableInsertTextCallback , #if ENABLE_OVERLOADING EditableInsertTextSignalInfo , #endif afterEditableInsertText , genClosure_EditableInsertText , mk_EditableInsertTextCallback , noEditableInsertTextCallback , onEditableInsertText , wrap_EditableInsertTextCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object -- interface Editable -- | Memory-managed wrapper type. newtype Editable = Editable (ManagedPtr Editable) -- | A convenience alias for `Nothing` :: `Maybe` `Editable`. noEditable :: Maybe Editable noEditable = Nothing -- signal Editable::changed {- | The ::changed signal is emitted at the end of a single user-visible operation on the contents of the 'GI.Gtk.Interfaces.Editable.Editable'. E.g., a paste operation that replaces the contents of the selection will cause only one signal emission (even though it is implemented by first deleting the selection, then inserting the new content, and may cause multiple ::notify::text signals to be emitted). -} type EditableChangedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `EditableChangedCallback`@. noEditableChangedCallback :: Maybe EditableChangedCallback noEditableChangedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EditableChangedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EditableChangedCallback`. foreign import ccall "wrapper" mk_EditableChangedCallback :: C_EditableChangedCallback -> IO (FunPtr C_EditableChangedCallback) -- | Wrap the callback into a `GClosure`. genClosure_EditableChanged :: MonadIO m => EditableChangedCallback -> m (GClosure C_EditableChangedCallback) genClosure_EditableChanged cb = liftIO $ do let cb' = wrap_EditableChangedCallback cb mk_EditableChangedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `EditableChangedCallback` into a `C_EditableChangedCallback`. wrap_EditableChangedCallback :: EditableChangedCallback -> C_EditableChangedCallback wrap_EditableChangedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@changed@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' editable #changed callback @ -} onEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId onEditableChanged obj cb = liftIO $ do let cb' = wrap_EditableChangedCallback cb cb'' <- mk_EditableChangedCallback cb' connectSignalFunPtr obj "changed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@changed@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' editable #changed callback @ -} afterEditableChanged :: (IsEditable a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId afterEditableChanged obj cb = liftIO $ do let cb' = wrap_EditableChangedCallback cb cb'' <- mk_EditableChangedCallback cb' connectSignalFunPtr obj "changed" cb'' SignalConnectAfter -- signal Editable::delete-text {- | This signal is emitted when text is deleted from the widget by the user. The default handler for this signal will normally be responsible for deleting the text, so by connecting to this signal and then stopping the signal with 'GI.GObject.Functions.signalStopEmission', it is possible to modify the range of deleted text, or prevent it from being deleted entirely. The /@startPos@/ and /@endPos@/ parameters are interpreted as for 'GI.Gtk.Interfaces.Editable.editableDeleteText'. -} type EditableDeleteTextCallback = Int32 {- ^ /@startPos@/: the starting position -} -> Int32 {- ^ /@endPos@/: the end position -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `EditableDeleteTextCallback`@. noEditableDeleteTextCallback :: Maybe EditableDeleteTextCallback noEditableDeleteTextCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EditableDeleteTextCallback = Ptr () -> -- object Int32 -> Int32 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EditableDeleteTextCallback`. foreign import ccall "wrapper" mk_EditableDeleteTextCallback :: C_EditableDeleteTextCallback -> IO (FunPtr C_EditableDeleteTextCallback) -- | Wrap the callback into a `GClosure`. genClosure_EditableDeleteText :: MonadIO m => EditableDeleteTextCallback -> m (GClosure C_EditableDeleteTextCallback) genClosure_EditableDeleteText cb = liftIO $ do let cb' = wrap_EditableDeleteTextCallback cb mk_EditableDeleteTextCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `EditableDeleteTextCallback` into a `C_EditableDeleteTextCallback`. wrap_EditableDeleteTextCallback :: EditableDeleteTextCallback -> C_EditableDeleteTextCallback wrap_EditableDeleteTextCallback _cb _ startPos endPos _ = do _cb startPos endPos {- | Connect a signal handler for the “@delete-text@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' editable #deleteText callback @ -} onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId onEditableDeleteText obj cb = liftIO $ do let cb' = wrap_EditableDeleteTextCallback cb cb'' <- mk_EditableDeleteTextCallback cb' connectSignalFunPtr obj "delete-text" cb'' SignalConnectBefore {- | Connect a signal handler for the “@delete-text@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' editable #deleteText callback @ -} afterEditableDeleteText :: (IsEditable a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId afterEditableDeleteText obj cb = liftIO $ do let cb' = wrap_EditableDeleteTextCallback cb cb'' <- mk_EditableDeleteTextCallback cb' connectSignalFunPtr obj "delete-text" cb'' SignalConnectAfter -- signal Editable::insert-text {- | This signal is emitted when text is inserted into the widget by the user. The default handler for this signal will normally be responsible for inserting the text, so by connecting to this signal and then stopping the signal with 'GI.GObject.Functions.signalStopEmission', it is possible to modify the inserted text, or prevent it from being inserted entirely. -} type EditableInsertTextCallback = T.Text {- ^ /@newText@/: the new text to insert -} -> Int32 {- ^ /@newTextLength@/: the length of the new text, in bytes, or -1 if new_text is nul-terminated -} -> Int32 {- ^ /@position@/: the position, in characters, at which to insert the new text. this is an in-out parameter. After the signal emission is finished, it should point after the newly inserted text. -} -> IO (Int32) -- | A convenience synonym for @`Nothing` :: `Maybe` `EditableInsertTextCallback`@. noEditableInsertTextCallback :: Maybe EditableInsertTextCallback noEditableInsertTextCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EditableInsertTextCallback = Ptr () -> -- object CString -> Int32 -> Ptr Int32 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EditableInsertTextCallback`. foreign import ccall "wrapper" mk_EditableInsertTextCallback :: C_EditableInsertTextCallback -> IO (FunPtr C_EditableInsertTextCallback) -- | Wrap the callback into a `GClosure`. genClosure_EditableInsertText :: MonadIO m => EditableInsertTextCallback -> m (GClosure C_EditableInsertTextCallback) genClosure_EditableInsertText cb = liftIO $ do let cb' = wrap_EditableInsertTextCallback cb mk_EditableInsertTextCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `EditableInsertTextCallback` into a `C_EditableInsertTextCallback`. wrap_EditableInsertTextCallback :: EditableInsertTextCallback -> C_EditableInsertTextCallback wrap_EditableInsertTextCallback _cb _ newText newTextLength position _ = do newText' <- cstringToText newText position' <- peek position outposition <- _cb newText' newTextLength position' poke position outposition {- | Connect a signal handler for the “@insert-text@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' editable #insertText callback @ -} onEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId onEditableInsertText obj cb = liftIO $ do let cb' = wrap_EditableInsertTextCallback cb cb'' <- mk_EditableInsertTextCallback cb' connectSignalFunPtr obj "insert-text" cb'' SignalConnectBefore {- | Connect a signal handler for the “@insert-text@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' editable #insertText callback @ -} afterEditableInsertText :: (IsEditable a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId afterEditableInsertText obj cb = liftIO $ do let cb' = wrap_EditableInsertTextCallback cb cb'' <- mk_EditableInsertTextCallback cb' connectSignalFunPtr obj "insert-text" cb'' SignalConnectAfter #if ENABLE_OVERLOADING data EditableChangedSignalInfo instance SignalInfo EditableChangedSignalInfo where type HaskellCallbackType EditableChangedSignalInfo = EditableChangedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EditableChangedCallback cb cb'' <- mk_EditableChangedCallback cb' connectSignalFunPtr obj "changed" cb'' connectMode data EditableDeleteTextSignalInfo instance SignalInfo EditableDeleteTextSignalInfo where type HaskellCallbackType EditableDeleteTextSignalInfo = EditableDeleteTextCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EditableDeleteTextCallback cb cb'' <- mk_EditableDeleteTextCallback cb' connectSignalFunPtr obj "delete-text" cb'' connectMode data EditableInsertTextSignalInfo instance SignalInfo EditableInsertTextSignalInfo where type HaskellCallbackType EditableInsertTextSignalInfo = EditableInsertTextCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EditableInsertTextCallback cb cb'' <- mk_EditableInsertTextCallback cb' connectSignalFunPtr obj "insert-text" cb'' connectMode type instance O.SignalList Editable = EditableSignalList type EditableSignalList = ('[ '("changed", EditableChangedSignalInfo), '("deleteText", EditableDeleteTextSignalInfo), '("insertText", EditableInsertTextSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif foreign import ccall "gtk_editable_get_type" c_gtk_editable_get_type :: IO GType instance GObject Editable where gobjectType = c_gtk_editable_get_type -- | Type class for types which can be safely cast to `Editable`, for instance with `toEditable`. class (GObject o, O.IsDescendantOf Editable o) => IsEditable o instance (GObject o, O.IsDescendantOf Editable o) => IsEditable o instance O.HasParentTypes Editable type instance O.ParentTypes Editable = '[GObject.Object.Object] -- | Cast to `Editable`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toEditable :: (MonadIO m, IsEditable o) => o -> m Editable toEditable = liftIO . unsafeCastTo Editable #if ENABLE_OVERLOADING instance O.HasAttributeList Editable type instance O.AttributeList Editable = EditableAttributeList type EditableAttributeList = ('[ ] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING type family ResolveEditableMethod (t :: Symbol) (o :: *) :: * where ResolveEditableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveEditableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveEditableMethod "copyClipboard" o = EditableCopyClipboardMethodInfo ResolveEditableMethod "cutClipboard" o = EditableCutClipboardMethodInfo ResolveEditableMethod "deleteSelection" o = EditableDeleteSelectionMethodInfo ResolveEditableMethod "deleteText" o = EditableDeleteTextMethodInfo ResolveEditableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveEditableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveEditableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveEditableMethod "insertText" o = EditableInsertTextMethodInfo ResolveEditableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveEditableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveEditableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveEditableMethod "pasteClipboard" o = EditablePasteClipboardMethodInfo ResolveEditableMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveEditableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveEditableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveEditableMethod "selectRegion" o = EditableSelectRegionMethodInfo ResolveEditableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveEditableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveEditableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveEditableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveEditableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveEditableMethod "getChars" o = EditableGetCharsMethodInfo ResolveEditableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveEditableMethod "getEditable" o = EditableGetEditableMethodInfo ResolveEditableMethod "getPosition" o = EditableGetPositionMethodInfo ResolveEditableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveEditableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveEditableMethod "getSelectionBounds" o = EditableGetSelectionBoundsMethodInfo ResolveEditableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveEditableMethod "setEditable" o = EditableSetEditableMethodInfo ResolveEditableMethod "setPosition" o = EditableSetPositionMethodInfo ResolveEditableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveEditableMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveEditableMethod t Editable, O.MethodInfo info Editable p) => OL.IsLabel t (Editable -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- method Editable::copy_clipboard -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_copy_clipboard" gtk_editable_copy_clipboard :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) IO () {- | Copies the contents of the currently selected content in the editable and puts it on the clipboard. -} editableCopyClipboard :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m () editableCopyClipboard editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_copy_clipboard editable' touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableCopyClipboardMethodInfo instance (signature ~ (m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableCopyClipboardMethodInfo a signature where overloadedMethod _ = editableCopyClipboard #endif -- method Editable::cut_clipboard -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_cut_clipboard" gtk_editable_cut_clipboard :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) IO () {- | Removes the contents of the currently selected content in the editable and puts it on the clipboard. -} editableCutClipboard :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m () editableCutClipboard editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_cut_clipboard editable' touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableCutClipboardMethodInfo instance (signature ~ (m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableCutClipboardMethodInfo a signature where overloadedMethod _ = editableCutClipboard #endif -- method Editable::delete_selection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_delete_selection" gtk_editable_delete_selection :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) IO () {- | Deletes the currently selected text of the editable. This call doesn’t do anything if there is no selected text. -} editableDeleteSelection :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m () editableDeleteSelection editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_delete_selection editable' touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableDeleteSelectionMethodInfo instance (signature ~ (m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableDeleteSelectionMethodInfo a signature where overloadedMethod _ = editableDeleteSelection #endif -- method Editable::delete_text -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_delete_text" gtk_editable_delete_text :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) Int32 -> -- start_pos : TBasicType TInt Int32 -> -- end_pos : TBasicType TInt IO () {- | Deletes a sequence of characters. The characters that are deleted are those characters at positions from /@startPos@/ up to, but not including /@endPos@/. If /@endPos@/ is negative, then the characters deleted are those from /@startPos@/ to the end of the text. Note that the positions are specified in characters, not bytes. -} editableDeleteText :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> Int32 {- ^ /@startPos@/: start position -} -> Int32 {- ^ /@endPos@/: end position -} -> m () editableDeleteText editable startPos endPos = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_delete_text editable' startPos endPos touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableDeleteTextMethodInfo instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableDeleteTextMethodInfo a signature where overloadedMethod _ = editableDeleteText #endif -- method Editable::get_chars -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start of text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end of text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gtk_editable_get_chars" gtk_editable_get_chars :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) Int32 -> -- start_pos : TBasicType TInt Int32 -> -- end_pos : TBasicType TInt IO CString {- | Retrieves a sequence of characters. The characters that are retrieved are those characters at positions from /@startPos@/ up to, but not including /@endPos@/. If /@endPos@/ is negative, then the characters retrieved are those characters from /@startPos@/ to the end of the text. Note that positions are specified in characters, not bytes. -} editableGetChars :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> Int32 {- ^ /@startPos@/: start of text -} -> Int32 {- ^ /@endPos@/: end of text -} -> m T.Text {- ^ __Returns:__ a pointer to the contents of the widget as a string. This string is allocated by the 'GI.Gtk.Interfaces.Editable.Editable' implementation and should be freed by the caller. -} editableGetChars editable startPos endPos = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable result <- gtk_editable_get_chars editable' startPos endPos checkUnexpectedReturnNULL "editableGetChars" result result' <- cstringToText result freeMem result touchManagedPtr editable return result' #if ENABLE_OVERLOADING data EditableGetCharsMethodInfo instance (signature ~ (Int32 -> Int32 -> m T.Text), MonadIO m, IsEditable a) => O.MethodInfo EditableGetCharsMethodInfo a signature where overloadedMethod _ = editableGetChars #endif -- method Editable::get_editable -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_editable_get_editable" gtk_editable_get_editable :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) IO CInt {- | Retrieves whether /@editable@/ is editable. See 'GI.Gtk.Interfaces.Editable.editableSetEditable'. -} editableGetEditable :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m Bool {- ^ __Returns:__ 'True' if /@editable@/ is editable. -} editableGetEditable editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable result <- gtk_editable_get_editable editable' let result' = (/= 0) result touchManagedPtr editable return result' #if ENABLE_OVERLOADING data EditableGetEditableMethodInfo instance (signature ~ (m Bool), MonadIO m, IsEditable a) => O.MethodInfo EditableGetEditableMethodInfo a signature where overloadedMethod _ = editableGetEditable #endif -- method Editable::get_position -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "gtk_editable_get_position" gtk_editable_get_position :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) IO Int32 {- | Retrieves the current position of the cursor relative to the start of the content of the editable. Note that this position is in characters, not in bytes. -} editableGetPosition :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m Int32 {- ^ __Returns:__ the cursor position -} editableGetPosition editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable result <- gtk_editable_get_position editable' touchManagedPtr editable return result #if ENABLE_OVERLOADING data EditableGetPositionMethodInfo instance (signature ~ (m Int32), MonadIO m, IsEditable a) => O.MethodInfo EditableGetPositionMethodInfo a signature where overloadedMethod _ = editableGetPosition #endif -- method Editable::get_selection_bounds -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the starting position, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the end position, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_editable_get_selection_bounds" gtk_editable_get_selection_bounds :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) Ptr Int32 -> -- start_pos : TBasicType TInt Ptr Int32 -> -- end_pos : TBasicType TInt IO CInt {- | Retrieves the selection bound of the editable. start_pos will be filled with the start of the selection and /@endPos@/ with end. If no text was selected both will be identical and 'False' will be returned. Note that positions are specified in characters, not bytes. -} editableGetSelectionBounds :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m ((Bool, Int32, Int32)) {- ^ __Returns:__ 'True' if an area is selected, 'False' otherwise -} editableGetSelectionBounds editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable startPos <- allocMem :: IO (Ptr Int32) endPos <- allocMem :: IO (Ptr Int32) result <- gtk_editable_get_selection_bounds editable' startPos endPos let result' = (/= 0) result startPos' <- peek startPos endPos' <- peek endPos touchManagedPtr editable freeMem startPos freeMem endPos return (result', startPos', endPos') #if ENABLE_OVERLOADING data EditableGetSelectionBoundsMethodInfo instance (signature ~ (m ((Bool, Int32, Int32))), MonadIO m, IsEditable a) => O.MethodInfo EditableGetSelectionBoundsMethodInfo a signature where overloadedMethod _ = editableGetSelectionBounds #endif -- method Editable::insert_text -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to append", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_text_length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the text in bytes, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionInout, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location of the position text will be inserted at", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_insert_text" gtk_editable_insert_text :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) CString -> -- new_text : TBasicType TUTF8 Int32 -> -- new_text_length : TBasicType TInt Ptr Int32 -> -- position : TBasicType TInt IO () {- | Inserts /@newTextLength@/ bytes of /@newText@/ into the contents of the widget, at position /@position@/. Note that the position is in characters, not in bytes. The function updates /@position@/ to point after the newly inserted text. -} editableInsertText :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> T.Text {- ^ /@newText@/: the text to append -} -> Int32 {- ^ /@newTextLength@/: the length of the text in bytes, or -1 -} -> Int32 {- ^ /@position@/: location of the position text will be inserted at -} -> m (Int32) editableInsertText editable newText newTextLength position = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable newText' <- textToCString newText position' <- allocMem :: IO (Ptr Int32) poke position' position gtk_editable_insert_text editable' newText' newTextLength position' position'' <- peek position' touchManagedPtr editable freeMem newText' freeMem position' return position'' #if ENABLE_OVERLOADING data EditableInsertTextMethodInfo instance (signature ~ (T.Text -> Int32 -> Int32 -> m (Int32)), MonadIO m, IsEditable a) => O.MethodInfo EditableInsertTextMethodInfo a signature where overloadedMethod _ = editableInsertText #endif -- method Editable::paste_clipboard -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_paste_clipboard" gtk_editable_paste_clipboard :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) IO () {- | Pastes the content of the clipboard to the current position of the cursor in the editable. -} editablePasteClipboard :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> m () editablePasteClipboard editable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_paste_clipboard editable' touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditablePasteClipboardMethodInfo instance (signature ~ (m ()), MonadIO m, IsEditable a) => O.MethodInfo EditablePasteClipboardMethodInfo a signature where overloadedMethod _ = editablePasteClipboard #endif -- method Editable::select_region -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start of region", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end of region", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_select_region" gtk_editable_select_region :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) Int32 -> -- start_pos : TBasicType TInt Int32 -> -- end_pos : TBasicType TInt IO () {- | Selects a region of text. The characters that are selected are those characters at positions from /@startPos@/ up to, but not including /@endPos@/. If /@endPos@/ is negative, then the characters selected are those characters from /@startPos@/ to the end of the text. Note that positions are specified in characters, not bytes. -} editableSelectRegion :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> Int32 {- ^ /@startPos@/: start of region -} -> Int32 {- ^ /@endPos@/: end of region -} -> m () editableSelectRegion editable startPos endPos = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_select_region editable' startPos endPos touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableSelectRegionMethodInfo instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableSelectRegionMethodInfo a signature where overloadedMethod _ = editableSelectRegion #endif -- method Editable::set_editable -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the user is allowed to edit the text\n in the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_set_editable" gtk_editable_set_editable :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) CInt -> -- is_editable : TBasicType TBoolean IO () {- | Determines if the user can edit the text in the editable widget or not. -} editableSetEditable :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> Bool {- ^ /@isEditable@/: 'True' if the user is allowed to edit the text in the widget -} -> m () editableSetEditable editable isEditable = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable let isEditable' = (fromIntegral . fromEnum) isEditable gtk_editable_set_editable editable' isEditable' touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableSetEditableMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableSetEditableMethodInfo a signature where overloadedMethod _ = editableSetEditable #endif -- method Editable::set_position -- method type : OrdinaryMethod -- Args : [Arg {argCName = "editable", argType = TInterface (Name {namespace = "Gtk", name = "Editable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEditable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position of the cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_editable_set_position" gtk_editable_set_position :: Ptr Editable -> -- editable : TInterface (Name {namespace = "Gtk", name = "Editable"}) Int32 -> -- position : TBasicType TInt IO () {- | Sets the cursor position in the editable to the given value. The cursor is displayed before the character with the given (base 0) index in the contents of the editable. The value must be less than or equal to the number of characters in the editable. A value of -1 indicates that the position should be set after the last character of the editable. Note that /@position@/ is in characters, not in bytes. -} editableSetPosition :: (B.CallStack.HasCallStack, MonadIO m, IsEditable a) => a {- ^ /@editable@/: a 'GI.Gtk.Interfaces.Editable.Editable' -} -> Int32 {- ^ /@position@/: the position of the cursor -} -> m () editableSetPosition editable position = liftIO $ do editable' <- unsafeManagedPtrCastPtr editable gtk_editable_set_position editable' position touchManagedPtr editable return () #if ENABLE_OVERLOADING data EditableSetPositionMethodInfo instance (signature ~ (Int32 -> m ()), MonadIO m, IsEditable a) => O.MethodInfo EditableSetPositionMethodInfo a signature where overloadedMethod _ = editableSetPosition #endif