{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Interfaces.Text
(
Text(..) ,
IsText ,
toText ,
#if defined(ENABLE_OVERLOADING)
ResolveTextMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TextAddSelectionMethodInfo ,
#endif
textAddSelection ,
textFreeRanges ,
#if defined(ENABLE_OVERLOADING)
TextGetBoundedRangesMethodInfo ,
#endif
textGetBoundedRanges ,
#if defined(ENABLE_OVERLOADING)
TextGetCaretOffsetMethodInfo ,
#endif
textGetCaretOffset ,
#if defined(ENABLE_OVERLOADING)
TextGetCharacterAtOffsetMethodInfo ,
#endif
textGetCharacterAtOffset ,
#if defined(ENABLE_OVERLOADING)
TextGetCharacterCountMethodInfo ,
#endif
textGetCharacterCount ,
#if defined(ENABLE_OVERLOADING)
TextGetCharacterExtentsMethodInfo ,
#endif
textGetCharacterExtents ,
#if defined(ENABLE_OVERLOADING)
TextGetDefaultAttributesMethodInfo ,
#endif
textGetDefaultAttributes ,
#if defined(ENABLE_OVERLOADING)
TextGetNSelectionsMethodInfo ,
#endif
textGetNSelections ,
#if defined(ENABLE_OVERLOADING)
TextGetOffsetAtPointMethodInfo ,
#endif
textGetOffsetAtPoint ,
#if defined(ENABLE_OVERLOADING)
TextGetRangeExtentsMethodInfo ,
#endif
textGetRangeExtents ,
#if defined(ENABLE_OVERLOADING)
TextGetRunAttributesMethodInfo ,
#endif
textGetRunAttributes ,
#if defined(ENABLE_OVERLOADING)
TextGetSelectionMethodInfo ,
#endif
textGetSelection ,
#if defined(ENABLE_OVERLOADING)
TextGetStringAtOffsetMethodInfo ,
#endif
textGetStringAtOffset ,
#if defined(ENABLE_OVERLOADING)
TextGetTextMethodInfo ,
#endif
textGetText ,
#if defined(ENABLE_OVERLOADING)
TextGetTextAfterOffsetMethodInfo ,
#endif
textGetTextAfterOffset ,
#if defined(ENABLE_OVERLOADING)
TextGetTextAtOffsetMethodInfo ,
#endif
textGetTextAtOffset ,
#if defined(ENABLE_OVERLOADING)
TextGetTextBeforeOffsetMethodInfo ,
#endif
textGetTextBeforeOffset ,
#if defined(ENABLE_OVERLOADING)
TextRemoveSelectionMethodInfo ,
#endif
textRemoveSelection ,
#if defined(ENABLE_OVERLOADING)
TextScrollSubstringToMethodInfo ,
#endif
textScrollSubstringTo ,
#if defined(ENABLE_OVERLOADING)
TextScrollSubstringToPointMethodInfo ,
#endif
textScrollSubstringToPoint ,
#if defined(ENABLE_OVERLOADING)
TextSetCaretOffsetMethodInfo ,
#endif
textSetCaretOffset ,
#if defined(ENABLE_OVERLOADING)
TextSetSelectionMethodInfo ,
#endif
textSetSelection ,
TextTextAttributesChangedCallback ,
#if defined(ENABLE_OVERLOADING)
TextTextAttributesChangedSignalInfo ,
#endif
afterTextTextAttributesChanged ,
onTextTextAttributesChanged ,
TextTextCaretMovedCallback ,
#if defined(ENABLE_OVERLOADING)
TextTextCaretMovedSignalInfo ,
#endif
afterTextTextCaretMoved ,
onTextTextCaretMoved ,
TextTextChangedCallback ,
#if defined(ENABLE_OVERLOADING)
TextTextChangedSignalInfo ,
#endif
afterTextTextChanged ,
onTextTextChanged ,
TextTextInsertCallback ,
#if defined(ENABLE_OVERLOADING)
TextTextInsertSignalInfo ,
#endif
afterTextTextInsert ,
onTextTextInsert ,
TextTextRemoveCallback ,
#if defined(ENABLE_OVERLOADING)
TextTextRemoveSignalInfo ,
#endif
afterTextTextRemove ,
onTextTextRemove ,
TextTextSelectionChangedCallback ,
#if defined(ENABLE_OVERLOADING)
TextTextSelectionChangedSignalInfo ,
#endif
afterTextTextSelectionChanged ,
onTextTextSelectionChanged ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R
import {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
import {-# SOURCE #-} qualified GI.Atk.Structs.TextRange as Atk.TextRange
import {-# SOURCE #-} qualified GI.Atk.Structs.TextRectangle as Atk.TextRectangle
import qualified GI.GObject.Objects.Object as GObject.Object
newtype Text = Text (SP.ManagedPtr Text)
deriving (Text -> Text -> Bool
(Text -> Text -> Bool) -> (Text -> Text -> Bool) -> Eq Text
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Text -> Text -> Bool
$c/= :: Text -> Text -> Bool
== :: Text -> Text -> Bool
$c== :: Text -> Text -> Bool
Eq)
instance SP.ManagedPtrNewtype Text where
toManagedPtr :: Text -> ManagedPtr Text
toManagedPtr (Text ManagedPtr Text
p) = ManagedPtr Text
p
foreign import ccall "atk_text_get_type"
c_atk_text_get_type :: IO B.Types.GType
instance B.Types.TypedObject Text where
glibType :: IO GType
glibType = IO GType
c_atk_text_get_type
instance B.Types.GObject Text
class (SP.GObject o, O.IsDescendantOf Text o) => IsText o
instance (SP.GObject o, O.IsDescendantOf Text o) => IsText o
instance O.HasParentTypes Text
type instance O.ParentTypes Text = '[GObject.Object.Object]
toText :: (MIO.MonadIO m, IsText o) => o -> m Text
toText :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m Text
toText = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> (o -> IO Text) -> o -> m Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Text -> Text) -> o -> IO Text
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Text -> Text
Text
instance B.GValue.IsGValue (Maybe Text) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_text_get_type
gvalueSet_ :: Ptr GValue -> Maybe Text -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Text
P.Nothing = Ptr GValue -> Ptr Text -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Text
forall a. Ptr a
FP.nullPtr :: FP.Ptr Text)
gvalueSet_ Ptr GValue
gv (P.Just Text
obj) = Text -> (Ptr Text -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Text
obj (Ptr GValue -> Ptr Text -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Text)
gvalueGet_ Ptr GValue
gv = do
Ptr Text
ptr <- Ptr GValue -> IO (Ptr Text)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Text)
if Ptr Text
ptr Ptr Text -> Ptr Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Text
forall a. Ptr a
FP.nullPtr
then Text -> Maybe Text
forall a. a -> Maybe a
P.Just (Text -> Maybe Text) -> IO Text -> IO (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Text -> Text
Text Ptr Text
ptr
else Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Text
type instance O.AttributeList Text = TextAttributeList
type TextAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTextMethod (t :: Symbol) (o :: *) :: * where
ResolveTextMethod "addSelection" o = TextAddSelectionMethodInfo
ResolveTextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveTextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTextMethod "removeSelection" o = TextRemoveSelectionMethodInfo
ResolveTextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTextMethod "scrollSubstringTo" o = TextScrollSubstringToMethodInfo
ResolveTextMethod "scrollSubstringToPoint" o = TextScrollSubstringToPointMethodInfo
ResolveTextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveTextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTextMethod "getBoundedRanges" o = TextGetBoundedRangesMethodInfo
ResolveTextMethod "getCaretOffset" o = TextGetCaretOffsetMethodInfo
ResolveTextMethod "getCharacterAtOffset" o = TextGetCharacterAtOffsetMethodInfo
ResolveTextMethod "getCharacterCount" o = TextGetCharacterCountMethodInfo
ResolveTextMethod "getCharacterExtents" o = TextGetCharacterExtentsMethodInfo
ResolveTextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTextMethod "getDefaultAttributes" o = TextGetDefaultAttributesMethodInfo
ResolveTextMethod "getNSelections" o = TextGetNSelectionsMethodInfo
ResolveTextMethod "getOffsetAtPoint" o = TextGetOffsetAtPointMethodInfo
ResolveTextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTextMethod "getRangeExtents" o = TextGetRangeExtentsMethodInfo
ResolveTextMethod "getRunAttributes" o = TextGetRunAttributesMethodInfo
ResolveTextMethod "getSelection" o = TextGetSelectionMethodInfo
ResolveTextMethod "getStringAtOffset" o = TextGetStringAtOffsetMethodInfo
ResolveTextMethod "getText" o = TextGetTextMethodInfo
ResolveTextMethod "getTextAfterOffset" o = TextGetTextAfterOffsetMethodInfo
ResolveTextMethod "getTextAtOffset" o = TextGetTextAtOffsetMethodInfo
ResolveTextMethod "getTextBeforeOffset" o = TextGetTextBeforeOffsetMethodInfo
ResolveTextMethod "setCaretOffset" o = TextSetCaretOffsetMethodInfo
ResolveTextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTextMethod "setSelection" o = TextSetSelectionMethodInfo
ResolveTextMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTextMethod t Text, O.OverloadedMethod info Text p) => OL.IsLabel t (Text -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTextMethod t Text, O.OverloadedMethod info Text p, R.HasField t Text p) => R.HasField t Text p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTextMethod t Text, O.OverloadedMethodInfo info Text) => OL.IsLabel t (O.MethodProxy info Text) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "atk_text_add_selection" atk_text_add_selection ::
Ptr Text ->
Int32 ->
Int32 ->
IO CInt
textAddSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> m Bool
textAddSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> m Bool
textAddSelection a
text Int32
startOffset Int32
endOffset = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
CInt
result <- Ptr Text -> Int32 -> Int32 -> IO CInt
atk_text_add_selection Ptr Text
text' Int32
startOffset Int32
endOffset
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TextAddSelectionMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextAddSelectionMethodInfo a signature where
overloadedMethod = textAddSelection
instance O.OverloadedMethodInfo TextAddSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textAddSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textAddSelection"
})
#endif
foreign import ccall "atk_text_get_bounded_ranges" atk_text_get_bounded_ranges ::
Ptr Text ->
Ptr Atk.TextRectangle.TextRectangle ->
CUInt ->
CUInt ->
CUInt ->
IO (Ptr (Ptr Atk.TextRange.TextRange))
textGetBoundedRanges ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Atk.TextRectangle.TextRectangle
-> Atk.Enums.CoordType
-> Atk.Enums.TextClipType
-> Atk.Enums.TextClipType
-> m [Atk.TextRange.TextRange]
textGetBoundedRanges :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a
-> TextRectangle
-> CoordType
-> TextClipType
-> TextClipType
-> m [TextRange]
textGetBoundedRanges a
text TextRectangle
rect CoordType
coordType TextClipType
xClipType TextClipType
yClipType = IO [TextRange] -> m [TextRange]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TextRange] -> m [TextRange])
-> IO [TextRange] -> m [TextRange]
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Ptr TextRectangle
rect' <- TextRectangle -> IO (Ptr TextRectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextRectangle
rect
let coordType' :: CUInt
coordType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CoordType -> Int) -> CoordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoordType -> Int
forall a. Enum a => a -> Int
fromEnum) CoordType
coordType
let xClipType' :: CUInt
xClipType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextClipType -> Int) -> TextClipType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextClipType -> Int
forall a. Enum a => a -> Int
fromEnum) TextClipType
xClipType
let yClipType' :: CUInt
yClipType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextClipType -> Int) -> TextClipType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextClipType -> Int
forall a. Enum a => a -> Int
fromEnum) TextClipType
yClipType
Ptr (Ptr TextRange)
result <- Ptr Text
-> Ptr TextRectangle
-> CUInt
-> CUInt
-> CUInt
-> IO (Ptr (Ptr TextRange))
atk_text_get_bounded_ranges Ptr Text
text' Ptr TextRectangle
rect' CUInt
coordType' CUInt
xClipType' CUInt
yClipType'
Text -> Ptr (Ptr TextRange) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetBoundedRanges" Ptr (Ptr TextRange)
result
[Ptr TextRange]
result' <- Ptr (Ptr TextRange) -> IO [Ptr TextRange]
forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr TextRange)
result
[TextRange]
result'' <- (Ptr TextRange -> IO TextRange)
-> [Ptr TextRange] -> IO [TextRange]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr TextRange -> TextRange)
-> Ptr TextRange -> IO TextRange
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextRange -> TextRange
Atk.TextRange.TextRange) [Ptr TextRange]
result'
Ptr (Ptr TextRange) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr TextRange)
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
TextRectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextRectangle
rect
[TextRange] -> IO [TextRange]
forall (m :: * -> *) a. Monad m => a -> m a
return [TextRange]
result''
#if defined(ENABLE_OVERLOADING)
data TextGetBoundedRangesMethodInfo
instance (signature ~ (Atk.TextRectangle.TextRectangle -> Atk.Enums.CoordType -> Atk.Enums.TextClipType -> Atk.Enums.TextClipType -> m [Atk.TextRange.TextRange]), MonadIO m, IsText a) => O.OverloadedMethod TextGetBoundedRangesMethodInfo a signature where
overloadedMethod = textGetBoundedRanges
instance O.OverloadedMethodInfo TextGetBoundedRangesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetBoundedRanges",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetBoundedRanges"
})
#endif
foreign import ccall "atk_text_get_caret_offset" atk_text_get_caret_offset ::
Ptr Text ->
IO Int32
textGetCaretOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> m Int32
textGetCaretOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Int32
textGetCaretOffset a
text = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Int32
result <- Ptr Text -> IO Int32
atk_text_get_caret_offset Ptr Text
text'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TextGetCaretOffsetMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetCaretOffsetMethodInfo a signature where
overloadedMethod = textGetCaretOffset
instance O.OverloadedMethodInfo TextGetCaretOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetCaretOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetCaretOffset"
})
#endif
foreign import ccall "atk_text_get_character_at_offset" atk_text_get_character_at_offset ::
Ptr Text ->
Int32 ->
IO CInt
textGetCharacterAtOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> m Char
textGetCharacterAtOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m Char
textGetCharacterAtOffset a
text Int32
offset = IO Char -> m Char
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
CInt
result <- Ptr Text -> Int32 -> IO CInt
atk_text_get_character_at_offset Ptr Text
text' Int32
offset
let result' :: Char
result' = (Int -> Char
chr (Int -> Char) -> (CInt -> Int) -> CInt -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Char -> IO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'
#if defined(ENABLE_OVERLOADING)
data TextGetCharacterAtOffsetMethodInfo
instance (signature ~ (Int32 -> m Char), MonadIO m, IsText a) => O.OverloadedMethod TextGetCharacterAtOffsetMethodInfo a signature where
overloadedMethod = textGetCharacterAtOffset
instance O.OverloadedMethodInfo TextGetCharacterAtOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetCharacterAtOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetCharacterAtOffset"
})
#endif
foreign import ccall "atk_text_get_character_count" atk_text_get_character_count ::
Ptr Text ->
IO Int32
textGetCharacterCount ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> m Int32
textGetCharacterCount :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Int32
textGetCharacterCount a
text = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Int32
result <- Ptr Text -> IO Int32
atk_text_get_character_count Ptr Text
text'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TextGetCharacterCountMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetCharacterCountMethodInfo a signature where
overloadedMethod = textGetCharacterCount
instance O.OverloadedMethodInfo TextGetCharacterCountMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetCharacterCount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetCharacterCount"
})
#endif
foreign import ccall "atk_text_get_character_extents" atk_text_get_character_extents ::
Ptr Text ->
Int32 ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int32 ->
CUInt ->
IO ()
textGetCharacterExtents ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Atk.Enums.CoordType
-> m ((Int32, Int32, Int32, Int32))
textGetCharacterExtents :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> CoordType -> m (Int32, Int32, Int32, Int32)
textGetCharacterExtents a
text Int32
offset CoordType
coords = IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32))
-> IO (Int32, Int32, Int32, Int32)
-> m (Int32, Int32, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Ptr Int32
x <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
y <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
let coords' :: CUInt
coords' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CoordType -> Int) -> CoordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoordType -> Int
forall a. Enum a => a -> Int
fromEnum) CoordType
coords
Ptr Text
-> Int32
-> Ptr Int32
-> Ptr Int32
-> Ptr Int32
-> Ptr Int32
-> CUInt
-> IO ()
atk_text_get_character_extents Ptr Text
text' Int32
offset Ptr Int32
x Ptr Int32
y Ptr Int32
width Ptr Int32
height CUInt
coords'
Int32
x' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
x
Int32
y' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
y
Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
x
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
y
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
(Int32, Int32, Int32, Int32) -> IO (Int32, Int32, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
x', Int32
y', Int32
width', Int32
height')
#if defined(ENABLE_OVERLOADING)
data TextGetCharacterExtentsMethodInfo
instance (signature ~ (Int32 -> Atk.Enums.CoordType -> m ((Int32, Int32, Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetCharacterExtentsMethodInfo a signature where
overloadedMethod = textGetCharacterExtents
instance O.OverloadedMethodInfo TextGetCharacterExtentsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetCharacterExtents",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetCharacterExtents"
})
#endif
foreign import ccall "atk_text_get_default_attributes" atk_text_get_default_attributes ::
Ptr Text ->
IO (Ptr (GSList (Ptr ())))
textGetDefaultAttributes ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> m ([Ptr ()])
textGetDefaultAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m [Ptr ()]
textGetDefaultAttributes a
text = IO [Ptr ()] -> m [Ptr ()]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Ptr (GSList (Ptr ()))
result <- Ptr Text -> IO (Ptr (GSList (Ptr ())))
atk_text_get_default_attributes Ptr Text
text'
[Ptr ()]
result' <- Ptr (GSList (Ptr ())) -> IO [Ptr ()]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr ()))
result
Ptr (GSList (Ptr ())) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr ()))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
[Ptr ()] -> IO [Ptr ()]
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
result'
#if defined(ENABLE_OVERLOADING)
data TextGetDefaultAttributesMethodInfo
instance (signature ~ (m ([Ptr ()])), MonadIO m, IsText a) => O.OverloadedMethod TextGetDefaultAttributesMethodInfo a signature where
overloadedMethod = textGetDefaultAttributes
instance O.OverloadedMethodInfo TextGetDefaultAttributesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetDefaultAttributes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetDefaultAttributes"
})
#endif
foreign import ccall "atk_text_get_n_selections" atk_text_get_n_selections ::
Ptr Text ->
IO Int32
textGetNSelections ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> m Int32
textGetNSelections :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Int32
textGetNSelections a
text = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Int32
result <- Ptr Text -> IO Int32
atk_text_get_n_selections Ptr Text
text'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TextGetNSelectionsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetNSelectionsMethodInfo a signature where
overloadedMethod = textGetNSelections
instance O.OverloadedMethodInfo TextGetNSelectionsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetNSelections",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetNSelections"
})
#endif
foreign import ccall "atk_text_get_offset_at_point" atk_text_get_offset_at_point ::
Ptr Text ->
Int32 ->
Int32 ->
CUInt ->
IO Int32
textGetOffsetAtPoint ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> Atk.Enums.CoordType
-> m Int32
textGetOffsetAtPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> CoordType -> m Int32
textGetOffsetAtPoint a
text Int32
x Int32
y CoordType
coords = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let coords' :: CUInt
coords' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CoordType -> Int) -> CoordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoordType -> Int
forall a. Enum a => a -> Int
fromEnum) CoordType
coords
Int32
result <- Ptr Text -> Int32 -> Int32 -> CUInt -> IO Int32
atk_text_get_offset_at_point Ptr Text
text' Int32
x Int32
y CUInt
coords'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TextGetOffsetAtPointMethodInfo
instance (signature ~ (Int32 -> Int32 -> Atk.Enums.CoordType -> m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetOffsetAtPointMethodInfo a signature where
overloadedMethod = textGetOffsetAtPoint
instance O.OverloadedMethodInfo TextGetOffsetAtPointMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetOffsetAtPoint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetOffsetAtPoint"
})
#endif
foreign import ccall "atk_text_get_range_extents" atk_text_get_range_extents ::
Ptr Text ->
Int32 ->
Int32 ->
CUInt ->
Ptr Atk.TextRectangle.TextRectangle ->
IO ()
textGetRangeExtents ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> Atk.Enums.CoordType
-> m (Atk.TextRectangle.TextRectangle)
textGetRangeExtents :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> CoordType -> m TextRectangle
textGetRangeExtents a
text Int32
startOffset Int32
endOffset CoordType
coordType = IO TextRectangle -> m TextRectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextRectangle -> m TextRectangle)
-> IO TextRectangle -> m TextRectangle
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let coordType' :: CUInt
coordType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CoordType -> Int) -> CoordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoordType -> Int
forall a. Enum a => a -> Int
fromEnum) CoordType
coordType
Ptr TextRectangle
rect <- Int -> IO (Ptr TextRectangle)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
16 :: IO (Ptr Atk.TextRectangle.TextRectangle)
Ptr Text -> Int32 -> Int32 -> CUInt -> Ptr TextRectangle -> IO ()
atk_text_get_range_extents Ptr Text
text' Int32
startOffset Int32
endOffset CUInt
coordType' Ptr TextRectangle
rect
TextRectangle
rect' <- ((ManagedPtr TextRectangle -> TextRectangle)
-> Ptr TextRectangle -> IO TextRectangle
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TextRectangle -> TextRectangle
Atk.TextRectangle.TextRectangle) Ptr TextRectangle
rect
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
TextRectangle -> IO TextRectangle
forall (m :: * -> *) a. Monad m => a -> m a
return TextRectangle
rect'
#if defined(ENABLE_OVERLOADING)
data TextGetRangeExtentsMethodInfo
instance (signature ~ (Int32 -> Int32 -> Atk.Enums.CoordType -> m (Atk.TextRectangle.TextRectangle)), MonadIO m, IsText a) => O.OverloadedMethod TextGetRangeExtentsMethodInfo a signature where
overloadedMethod = textGetRangeExtents
instance O.OverloadedMethodInfo TextGetRangeExtentsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetRangeExtents",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetRangeExtents"
})
#endif
foreign import ccall "atk_text_get_run_attributes" atk_text_get_run_attributes ::
Ptr Text ->
Int32 ->
Ptr Int32 ->
Ptr Int32 ->
IO (Ptr (GSList (Ptr ())))
textGetRunAttributes ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> m (([Ptr ()], Int32, Int32))
textGetRunAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m ([Ptr ()], Int32, Int32)
textGetRunAttributes a
text Int32
offset = IO ([Ptr ()], Int32, Int32) -> m ([Ptr ()], Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ([Ptr ()], Int32, Int32) -> m ([Ptr ()], Int32, Int32))
-> IO ([Ptr ()], Int32, Int32) -> m ([Ptr ()], Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Ptr Int32
startOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
endOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr (GSList (Ptr ()))
result <- Ptr Text
-> Int32 -> Ptr Int32 -> Ptr Int32 -> IO (Ptr (GSList (Ptr ())))
atk_text_get_run_attributes Ptr Text
text' Int32
offset Ptr Int32
startOffset Ptr Int32
endOffset
[Ptr ()]
result' <- Ptr (GSList (Ptr ())) -> IO [Ptr ()]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr ()))
result
Ptr (GSList (Ptr ())) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr ()))
result
Int32
startOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
startOffset
Int32
endOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
endOffset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
startOffset
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
endOffset
([Ptr ()], Int32, Int32) -> IO ([Ptr ()], Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Ptr ()]
result', Int32
startOffset', Int32
endOffset')
#if defined(ENABLE_OVERLOADING)
data TextGetRunAttributesMethodInfo
instance (signature ~ (Int32 -> m (([Ptr ()], Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetRunAttributesMethodInfo a signature where
overloadedMethod = textGetRunAttributes
instance O.OverloadedMethodInfo TextGetRunAttributesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetRunAttributes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetRunAttributes"
})
#endif
foreign import ccall "atk_text_get_selection" atk_text_get_selection ::
Ptr Text ->
Int32 ->
Ptr Int32 ->
Ptr Int32 ->
IO CString
textGetSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> m ((T.Text, Int32, Int32))
textGetSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m (Text, Int32, Int32)
textGetSelection a
text Int32
selectionNum = IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Int32, Int32) -> m (Text, Int32, Int32))
-> IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
Ptr Int32
startOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
endOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CString
result <- Ptr Text -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO CString
atk_text_get_selection Ptr Text
text' Int32
selectionNum Ptr Int32
startOffset Ptr Int32
endOffset
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetSelection" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Int32
startOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
startOffset
Int32
endOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
endOffset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
startOffset
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
endOffset
(Text, Int32, Int32) -> IO (Text, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Int32
startOffset', Int32
endOffset')
#if defined(ENABLE_OVERLOADING)
data TextGetSelectionMethodInfo
instance (signature ~ (Int32 -> m ((T.Text, Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetSelectionMethodInfo a signature where
overloadedMethod = textGetSelection
instance O.OverloadedMethodInfo TextGetSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetSelection"
})
#endif
foreign import ccall "atk_text_get_string_at_offset" atk_text_get_string_at_offset ::
Ptr Text ->
Int32 ->
CUInt ->
Ptr Int32 ->
Ptr Int32 ->
IO CString
textGetStringAtOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Atk.Enums.TextGranularity
-> m ((Maybe T.Text, Int32, Int32))
textGetStringAtOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> TextGranularity -> m (Maybe Text, Int32, Int32)
textGetStringAtOffset a
text Int32
offset TextGranularity
granularity = IO (Maybe Text, Int32, Int32) -> m (Maybe Text, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Int32, Int32) -> m (Maybe Text, Int32, Int32))
-> IO (Maybe Text, Int32, Int32) -> m (Maybe Text, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let granularity' :: CUInt
granularity' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (TextGranularity -> Int) -> TextGranularity -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextGranularity -> Int
forall a. Enum a => a -> Int
fromEnum) TextGranularity
granularity
Ptr Int32
startOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
endOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CString
result <- Ptr Text -> Int32 -> CUInt -> Ptr Int32 -> Ptr Int32 -> IO CString
atk_text_get_string_at_offset Ptr Text
text' Int32
offset CUInt
granularity' Ptr Int32
startOffset Ptr Int32
endOffset
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Int32
startOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
startOffset
Int32
endOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
endOffset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
startOffset
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
endOffset
(Maybe Text, Int32, Int32) -> IO (Maybe Text, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Int32
startOffset', Int32
endOffset')
#if defined(ENABLE_OVERLOADING)
data TextGetStringAtOffsetMethodInfo
instance (signature ~ (Int32 -> Atk.Enums.TextGranularity -> m ((Maybe T.Text, Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetStringAtOffsetMethodInfo a signature where
overloadedMethod = textGetStringAtOffset
instance O.OverloadedMethodInfo TextGetStringAtOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetStringAtOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetStringAtOffset"
})
#endif
foreign import ccall "atk_text_get_text" atk_text_get_text ::
Ptr Text ->
Int32 ->
Int32 ->
IO CString
textGetText ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> m T.Text
textGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> m Text
textGetText a
text Int32
startOffset Int32
endOffset = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
CString
result <- Ptr Text -> Int32 -> Int32 -> IO CString
atk_text_get_text Ptr Text
text' Int32
startOffset Int32
endOffset
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetText" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data TextGetTextMethodInfo
instance (signature ~ (Int32 -> Int32 -> m T.Text), MonadIO m, IsText a) => O.OverloadedMethod TextGetTextMethodInfo a signature where
overloadedMethod = textGetText
instance O.OverloadedMethodInfo TextGetTextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetText",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetText"
})
#endif
foreign import ccall "atk_text_get_text_after_offset" atk_text_get_text_after_offset ::
Ptr Text ->
Int32 ->
CUInt ->
Ptr Int32 ->
Ptr Int32 ->
IO CString
{-# DEPRECATED textGetTextAfterOffset ["(Since version 2.9.3)","Please use 'GI.Atk.Interfaces.Text.textGetStringAtOffset' instead."] #-}
textGetTextAfterOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Atk.Enums.TextBoundary
-> m ((T.Text, Int32, Int32))
textGetTextAfterOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> TextBoundary -> m (Text, Int32, Int32)
textGetTextAfterOffset a
text Int32
offset TextBoundary
boundaryType = IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Int32, Int32) -> m (Text, Int32, Int32))
-> IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let boundaryType' :: CUInt
boundaryType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextBoundary -> Int) -> TextBoundary -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBoundary -> Int
forall a. Enum a => a -> Int
fromEnum) TextBoundary
boundaryType
Ptr Int32
startOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
endOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CString
result <- Ptr Text -> Int32 -> CUInt -> Ptr Int32 -> Ptr Int32 -> IO CString
atk_text_get_text_after_offset Ptr Text
text' Int32
offset CUInt
boundaryType' Ptr Int32
startOffset Ptr Int32
endOffset
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetTextAfterOffset" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Int32
startOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
startOffset
Int32
endOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
endOffset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
startOffset
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
endOffset
(Text, Int32, Int32) -> IO (Text, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Int32
startOffset', Int32
endOffset')
#if defined(ENABLE_OVERLOADING)
data TextGetTextAfterOffsetMethodInfo
instance (signature ~ (Int32 -> Atk.Enums.TextBoundary -> m ((T.Text, Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetTextAfterOffsetMethodInfo a signature where
overloadedMethod = textGetTextAfterOffset
instance O.OverloadedMethodInfo TextGetTextAfterOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetTextAfterOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetTextAfterOffset"
})
#endif
foreign import ccall "atk_text_get_text_at_offset" atk_text_get_text_at_offset ::
Ptr Text ->
Int32 ->
CUInt ->
Ptr Int32 ->
Ptr Int32 ->
IO CString
{-# DEPRECATED textGetTextAtOffset ["This method is deprecated since ATK version","2.9.4. Please use 'GI.Atk.Interfaces.Text.textGetStringAtOffset' instead."] #-}
textGetTextAtOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Atk.Enums.TextBoundary
-> m ((T.Text, Int32, Int32))
textGetTextAtOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> TextBoundary -> m (Text, Int32, Int32)
textGetTextAtOffset a
text Int32
offset TextBoundary
boundaryType = IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Int32, Int32) -> m (Text, Int32, Int32))
-> IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let boundaryType' :: CUInt
boundaryType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextBoundary -> Int) -> TextBoundary -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBoundary -> Int
forall a. Enum a => a -> Int
fromEnum) TextBoundary
boundaryType
Ptr Int32
startOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
endOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CString
result <- Ptr Text -> Int32 -> CUInt -> Ptr Int32 -> Ptr Int32 -> IO CString
atk_text_get_text_at_offset Ptr Text
text' Int32
offset CUInt
boundaryType' Ptr Int32
startOffset Ptr Int32
endOffset
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetTextAtOffset" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Int32
startOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
startOffset
Int32
endOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
endOffset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
startOffset
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
endOffset
(Text, Int32, Int32) -> IO (Text, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Int32
startOffset', Int32
endOffset')
#if defined(ENABLE_OVERLOADING)
data TextGetTextAtOffsetMethodInfo
instance (signature ~ (Int32 -> Atk.Enums.TextBoundary -> m ((T.Text, Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetTextAtOffsetMethodInfo a signature where
overloadedMethod = textGetTextAtOffset
instance O.OverloadedMethodInfo TextGetTextAtOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetTextAtOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetTextAtOffset"
})
#endif
foreign import ccall "atk_text_get_text_before_offset" atk_text_get_text_before_offset ::
Ptr Text ->
Int32 ->
CUInt ->
Ptr Int32 ->
Ptr Int32 ->
IO CString
{-# DEPRECATED textGetTextBeforeOffset ["(Since version 2.9.3)","Please use 'GI.Atk.Interfaces.Text.textGetStringAtOffset' instead."] #-}
textGetTextBeforeOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Atk.Enums.TextBoundary
-> m ((T.Text, Int32, Int32))
textGetTextBeforeOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> TextBoundary -> m (Text, Int32, Int32)
textGetTextBeforeOffset a
text Int32
offset TextBoundary
boundaryType = IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Int32, Int32) -> m (Text, Int32, Int32))
-> IO (Text, Int32, Int32) -> m (Text, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let boundaryType' :: CUInt
boundaryType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextBoundary -> Int) -> TextBoundary -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBoundary -> Int
forall a. Enum a => a -> Int
fromEnum) TextBoundary
boundaryType
Ptr Int32
startOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
endOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CString
result <- Ptr Text -> Int32 -> CUInt -> Ptr Int32 -> Ptr Int32 -> IO CString
atk_text_get_text_before_offset Ptr Text
text' Int32
offset CUInt
boundaryType' Ptr Int32
startOffset Ptr Int32
endOffset
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetTextBeforeOffset" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Int32
startOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
startOffset
Int32
endOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
endOffset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
startOffset
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
endOffset
(Text, Int32, Int32) -> IO (Text, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Int32
startOffset', Int32
endOffset')
#if defined(ENABLE_OVERLOADING)
data TextGetTextBeforeOffsetMethodInfo
instance (signature ~ (Int32 -> Atk.Enums.TextBoundary -> m ((T.Text, Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetTextBeforeOffsetMethodInfo a signature where
overloadedMethod = textGetTextBeforeOffset
instance O.OverloadedMethodInfo TextGetTextBeforeOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textGetTextBeforeOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textGetTextBeforeOffset"
})
#endif
foreign import ccall "atk_text_remove_selection" atk_text_remove_selection ::
Ptr Text ->
Int32 ->
IO CInt
textRemoveSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> m Bool
textRemoveSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m Bool
textRemoveSelection a
text Int32
selectionNum = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
CInt
result <- Ptr Text -> Int32 -> IO CInt
atk_text_remove_selection Ptr Text
text' Int32
selectionNum
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TextRemoveSelectionMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextRemoveSelectionMethodInfo a signature where
overloadedMethod = textRemoveSelection
instance O.OverloadedMethodInfo TextRemoveSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textRemoveSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textRemoveSelection"
})
#endif
foreign import ccall "atk_text_scroll_substring_to" atk_text_scroll_substring_to ::
Ptr Text ->
Int32 ->
Int32 ->
CUInt ->
IO CInt
textScrollSubstringTo ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> Atk.Enums.ScrollType
-> m Bool
textScrollSubstringTo :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> ScrollType -> m Bool
textScrollSubstringTo a
text Int32
startOffset Int32
endOffset ScrollType
type_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ScrollType -> Int) -> ScrollType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScrollType -> Int
forall a. Enum a => a -> Int
fromEnum) ScrollType
type_
CInt
result <- Ptr Text -> Int32 -> Int32 -> CUInt -> IO CInt
atk_text_scroll_substring_to Ptr Text
text' Int32
startOffset Int32
endOffset CUInt
type_'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TextScrollSubstringToMethodInfo
instance (signature ~ (Int32 -> Int32 -> Atk.Enums.ScrollType -> m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextScrollSubstringToMethodInfo a signature where
overloadedMethod = textScrollSubstringTo
instance O.OverloadedMethodInfo TextScrollSubstringToMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textScrollSubstringTo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textScrollSubstringTo"
})
#endif
foreign import ccall "atk_text_scroll_substring_to_point" atk_text_scroll_substring_to_point ::
Ptr Text ->
Int32 ->
Int32 ->
CUInt ->
Int32 ->
Int32 ->
IO CInt
textScrollSubstringToPoint ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> Atk.Enums.CoordType
-> Int32
-> Int32
-> m Bool
textScrollSubstringToPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> CoordType -> Int32 -> Int32 -> m Bool
textScrollSubstringToPoint a
text Int32
startOffset Int32
endOffset CoordType
coords Int32
x Int32
y = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
let coords' :: CUInt
coords' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CoordType -> Int) -> CoordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoordType -> Int
forall a. Enum a => a -> Int
fromEnum) CoordType
coords
CInt
result <- Ptr Text -> Int32 -> Int32 -> CUInt -> Int32 -> Int32 -> IO CInt
atk_text_scroll_substring_to_point Ptr Text
text' Int32
startOffset Int32
endOffset CUInt
coords' Int32
x Int32
y
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TextScrollSubstringToPointMethodInfo
instance (signature ~ (Int32 -> Int32 -> Atk.Enums.CoordType -> Int32 -> Int32 -> m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextScrollSubstringToPointMethodInfo a signature where
overloadedMethod = textScrollSubstringToPoint
instance O.OverloadedMethodInfo TextScrollSubstringToPointMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textScrollSubstringToPoint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textScrollSubstringToPoint"
})
#endif
foreign import ccall "atk_text_set_caret_offset" atk_text_set_caret_offset ::
Ptr Text ->
Int32 ->
IO CInt
textSetCaretOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> m Bool
textSetCaretOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m Bool
textSetCaretOffset a
text Int32
offset = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
CInt
result <- Ptr Text -> Int32 -> IO CInt
atk_text_set_caret_offset Ptr Text
text' Int32
offset
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TextSetCaretOffsetMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextSetCaretOffsetMethodInfo a signature where
overloadedMethod = textSetCaretOffset
instance O.OverloadedMethodInfo TextSetCaretOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textSetCaretOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textSetCaretOffset"
})
#endif
foreign import ccall "atk_text_set_selection" atk_text_set_selection ::
Ptr Text ->
Int32 ->
Int32 ->
Int32 ->
IO CInt
textSetSelection ::
(B.CallStack.HasCallStack, MonadIO m, IsText a) =>
a
-> Int32
-> Int32
-> Int32
-> m Bool
textSetSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> Int32 -> Int32 -> m Bool
textSetSelection a
text Int32
selectionNum Int32
startOffset Int32
endOffset = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Text
text' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
text
CInt
result <- Ptr Text -> Int32 -> Int32 -> Int32 -> IO CInt
atk_text_set_selection Ptr Text
text' Int32
selectionNum Int32
startOffset Int32
endOffset
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
text
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TextSetSelectionMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextSetSelectionMethodInfo a signature where
overloadedMethod = textSetSelection
instance O.OverloadedMethodInfo TextSetSelectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text.textSetSelection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#v:textSetSelection"
})
#endif
foreign import ccall "atk_text_free_ranges" atk_text_free_ranges ::
Ptr Atk.TextRange.TextRange ->
IO ()
textFreeRanges ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Atk.TextRange.TextRange]
-> m ()
textFreeRanges :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[TextRange] -> m ()
textFreeRanges [TextRange]
ranges = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
[Ptr TextRange]
ranges' <- (TextRange -> IO (Ptr TextRange))
-> [TextRange] -> IO [Ptr TextRange]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TextRange -> IO (Ptr TextRange)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [TextRange]
ranges
Ptr TextRange
ranges'' <- Int -> [Ptr TextRange] -> IO (Ptr TextRange)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray Int
32 [Ptr TextRange]
ranges'
Ptr TextRange -> IO ()
atk_text_free_ranges Ptr TextRange
ranges''
(TextRange -> IO ()) -> [TextRange] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TextRange -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [TextRange]
ranges
Ptr TextRange -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr TextRange
ranges''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
type TextTextAttributesChangedCallback =
IO ()
type C_TextTextAttributesChangedCallback =
Ptr Text ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TextTextAttributesChangedCallback :: C_TextTextAttributesChangedCallback -> IO (FunPtr C_TextTextAttributesChangedCallback)
wrap_TextTextAttributesChangedCallback ::
GObject a => (a -> TextTextAttributesChangedCallback) ->
C_TextTextAttributesChangedCallback
wrap_TextTextAttributesChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TextTextAttributesChangedCallback
wrap_TextTextAttributesChangedCallback a -> IO ()
gi'cb Ptr Text
gi'selfPtr Ptr ()
_ = do
Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> IO ()
gi'cb (Text -> a
Coerce.coerce Text
gi'self)
onTextTextAttributesChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextAttributesChangedCallback) -> m SignalHandlerId
onTextTextAttributesChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTextTextAttributesChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TextTextAttributesChangedCallback
wrapped' = (a -> IO ()) -> C_TextTextAttributesChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TextTextAttributesChangedCallback
wrap_TextTextAttributesChangedCallback a -> IO ()
wrapped
FunPtr C_TextTextAttributesChangedCallback
wrapped'' <- C_TextTextAttributesChangedCallback
-> IO (FunPtr C_TextTextAttributesChangedCallback)
mk_TextTextAttributesChangedCallback C_TextTextAttributesChangedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextAttributesChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-attributes-changed" FunPtr C_TextTextAttributesChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTextTextAttributesChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextAttributesChangedCallback) -> m SignalHandlerId
afterTextTextAttributesChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTextTextAttributesChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TextTextAttributesChangedCallback
wrapped' = (a -> IO ()) -> C_TextTextAttributesChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TextTextAttributesChangedCallback
wrap_TextTextAttributesChangedCallback a -> IO ()
wrapped
FunPtr C_TextTextAttributesChangedCallback
wrapped'' <- C_TextTextAttributesChangedCallback
-> IO (FunPtr C_TextTextAttributesChangedCallback)
mk_TextTextAttributesChangedCallback C_TextTextAttributesChangedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextAttributesChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-attributes-changed" FunPtr C_TextTextAttributesChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TextTextAttributesChangedSignalInfo
instance SignalInfo TextTextAttributesChangedSignalInfo where
type HaskellCallbackType TextTextAttributesChangedSignalInfo = TextTextAttributesChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TextTextAttributesChangedCallback cb
cb'' <- mk_TextTextAttributesChangedCallback cb'
connectSignalFunPtr obj "text-attributes-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text::text-attributes-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#g:signal:textAttributesChanged"})
#endif
type TextTextCaretMovedCallback =
Int32
-> IO ()
type C_TextTextCaretMovedCallback =
Ptr Text ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TextTextCaretMovedCallback :: C_TextTextCaretMovedCallback -> IO (FunPtr C_TextTextCaretMovedCallback)
wrap_TextTextCaretMovedCallback ::
GObject a => (a -> TextTextCaretMovedCallback) ->
C_TextTextCaretMovedCallback
wrap_TextTextCaretMovedCallback :: forall a.
GObject a =>
(a -> TextTextCaretMovedCallback) -> C_TextTextCaretMovedCallback
wrap_TextTextCaretMovedCallback a -> TextTextCaretMovedCallback
gi'cb Ptr Text
gi'selfPtr Int32
arg1 Ptr ()
_ = do
Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextTextCaretMovedCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self) Int32
arg1
onTextTextCaretMoved :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextCaretMovedCallback) -> m SignalHandlerId
onTextTextCaretMoved :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> ((?self::a) => TextTextCaretMovedCallback) -> m SignalHandlerId
onTextTextCaretMoved a
obj (?self::a) => TextTextCaretMovedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextCaretMovedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextCaretMovedCallback
TextTextCaretMovedCallback
cb
let wrapped' :: C_TextTextCaretMovedCallback
wrapped' = (a -> TextTextCaretMovedCallback) -> C_TextTextCaretMovedCallback
forall a.
GObject a =>
(a -> TextTextCaretMovedCallback) -> C_TextTextCaretMovedCallback
wrap_TextTextCaretMovedCallback a -> TextTextCaretMovedCallback
wrapped
FunPtr C_TextTextCaretMovedCallback
wrapped'' <- C_TextTextCaretMovedCallback
-> IO (FunPtr C_TextTextCaretMovedCallback)
mk_TextTextCaretMovedCallback C_TextTextCaretMovedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextCaretMovedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-caret-moved" FunPtr C_TextTextCaretMovedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTextTextCaretMoved :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextCaretMovedCallback) -> m SignalHandlerId
afterTextTextCaretMoved :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> ((?self::a) => TextTextCaretMovedCallback) -> m SignalHandlerId
afterTextTextCaretMoved a
obj (?self::a) => TextTextCaretMovedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextCaretMovedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextCaretMovedCallback
TextTextCaretMovedCallback
cb
let wrapped' :: C_TextTextCaretMovedCallback
wrapped' = (a -> TextTextCaretMovedCallback) -> C_TextTextCaretMovedCallback
forall a.
GObject a =>
(a -> TextTextCaretMovedCallback) -> C_TextTextCaretMovedCallback
wrap_TextTextCaretMovedCallback a -> TextTextCaretMovedCallback
wrapped
FunPtr C_TextTextCaretMovedCallback
wrapped'' <- C_TextTextCaretMovedCallback
-> IO (FunPtr C_TextTextCaretMovedCallback)
mk_TextTextCaretMovedCallback C_TextTextCaretMovedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextCaretMovedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-caret-moved" FunPtr C_TextTextCaretMovedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TextTextCaretMovedSignalInfo
instance SignalInfo TextTextCaretMovedSignalInfo where
type HaskellCallbackType TextTextCaretMovedSignalInfo = TextTextCaretMovedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TextTextCaretMovedCallback cb
cb'' <- mk_TextTextCaretMovedCallback cb'
connectSignalFunPtr obj "text-caret-moved" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text::text-caret-moved"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#g:signal:textCaretMoved"})
#endif
{-# DEPRECATED TextTextChangedCallback ["(Since version 2.9.4)","Use t'GI.Atk.Objects.Object.Object'::@/text-insert/@ or","t'GI.Atk.Objects.Object.Object'::@/text-remove/@ instead."] #-}
type TextTextChangedCallback =
Int32
-> Int32
-> IO ()
type C_TextTextChangedCallback =
Ptr Text ->
Int32 ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TextTextChangedCallback :: C_TextTextChangedCallback -> IO (FunPtr C_TextTextChangedCallback)
wrap_TextTextChangedCallback ::
GObject a => (a -> TextTextChangedCallback) ->
C_TextTextChangedCallback
wrap_TextTextChangedCallback :: forall a.
GObject a =>
(a -> TextTextChangedCallback) -> C_TextTextChangedCallback
wrap_TextTextChangedCallback a -> TextTextChangedCallback
gi'cb Ptr Text
gi'selfPtr Int32
arg1 Int32
arg2 Ptr ()
_ = do
Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextTextChangedCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self) Int32
arg1 Int32
arg2
onTextTextChanged :: (IsText a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TextTextChangedCallback) -> m SignalHandlerId
onTextTextChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TextTextChangedCallback)
-> m SignalHandlerId
onTextTextChanged a
obj Maybe Text
detail (?self::a) => TextTextChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextChangedCallback
TextTextChangedCallback
cb
let wrapped' :: C_TextTextChangedCallback
wrapped' = (a -> TextTextChangedCallback) -> C_TextTextChangedCallback
forall a.
GObject a =>
(a -> TextTextChangedCallback) -> C_TextTextChangedCallback
wrap_TextTextChangedCallback a -> TextTextChangedCallback
wrapped
FunPtr C_TextTextChangedCallback
wrapped'' <- C_TextTextChangedCallback -> IO (FunPtr C_TextTextChangedCallback)
mk_TextTextChangedCallback C_TextTextChangedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-changed" FunPtr C_TextTextChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail
afterTextTextChanged :: (IsText a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TextTextChangedCallback) -> m SignalHandlerId
afterTextTextChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TextTextChangedCallback)
-> m SignalHandlerId
afterTextTextChanged a
obj Maybe Text
detail (?self::a) => TextTextChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextChangedCallback
TextTextChangedCallback
cb
let wrapped' :: C_TextTextChangedCallback
wrapped' = (a -> TextTextChangedCallback) -> C_TextTextChangedCallback
forall a.
GObject a =>
(a -> TextTextChangedCallback) -> C_TextTextChangedCallback
wrap_TextTextChangedCallback a -> TextTextChangedCallback
wrapped
FunPtr C_TextTextChangedCallback
wrapped'' <- C_TextTextChangedCallback -> IO (FunPtr C_TextTextChangedCallback)
mk_TextTextChangedCallback C_TextTextChangedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-changed" FunPtr C_TextTextChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail
#if defined(ENABLE_OVERLOADING)
data TextTextChangedSignalInfo
instance SignalInfo TextTextChangedSignalInfo where
type HaskellCallbackType TextTextChangedSignalInfo = TextTextChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TextTextChangedCallback cb
cb'' <- mk_TextTextChangedCallback cb'
connectSignalFunPtr obj "text-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text::text-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#g:signal:textChanged"})
#endif
type TextTextInsertCallback =
Int32
-> Int32
-> T.Text
-> IO ()
type C_TextTextInsertCallback =
Ptr Text ->
Int32 ->
Int32 ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TextTextInsertCallback :: C_TextTextInsertCallback -> IO (FunPtr C_TextTextInsertCallback)
wrap_TextTextInsertCallback ::
GObject a => (a -> TextTextInsertCallback) ->
C_TextTextInsertCallback
wrap_TextTextInsertCallback :: forall a.
GObject a =>
(a -> TextTextInsertCallback) -> C_TextTextInsertCallback
wrap_TextTextInsertCallback a -> TextTextInsertCallback
gi'cb Ptr Text
gi'selfPtr Int32
arg1 Int32
arg2 CString
arg3 Ptr ()
_ = do
Text
arg3' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
arg3
Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextTextInsertCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self) Int32
arg1 Int32
arg2 Text
arg3'
onTextTextInsert :: (IsText a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TextTextInsertCallback) -> m SignalHandlerId
onTextTextInsert :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TextTextInsertCallback)
-> m SignalHandlerId
onTextTextInsert a
obj Maybe Text
detail (?self::a) => TextTextInsertCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextInsertCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextInsertCallback
TextTextInsertCallback
cb
let wrapped' :: C_TextTextInsertCallback
wrapped' = (a -> TextTextInsertCallback) -> C_TextTextInsertCallback
forall a.
GObject a =>
(a -> TextTextInsertCallback) -> C_TextTextInsertCallback
wrap_TextTextInsertCallback a -> TextTextInsertCallback
wrapped
FunPtr C_TextTextInsertCallback
wrapped'' <- C_TextTextInsertCallback -> IO (FunPtr C_TextTextInsertCallback)
mk_TextTextInsertCallback C_TextTextInsertCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextInsertCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-insert" FunPtr C_TextTextInsertCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail
afterTextTextInsert :: (IsText a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TextTextInsertCallback) -> m SignalHandlerId
afterTextTextInsert :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TextTextInsertCallback)
-> m SignalHandlerId
afterTextTextInsert a
obj Maybe Text
detail (?self::a) => TextTextInsertCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextInsertCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextInsertCallback
TextTextInsertCallback
cb
let wrapped' :: C_TextTextInsertCallback
wrapped' = (a -> TextTextInsertCallback) -> C_TextTextInsertCallback
forall a.
GObject a =>
(a -> TextTextInsertCallback) -> C_TextTextInsertCallback
wrap_TextTextInsertCallback a -> TextTextInsertCallback
wrapped
FunPtr C_TextTextInsertCallback
wrapped'' <- C_TextTextInsertCallback -> IO (FunPtr C_TextTextInsertCallback)
mk_TextTextInsertCallback C_TextTextInsertCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextInsertCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-insert" FunPtr C_TextTextInsertCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail
#if defined(ENABLE_OVERLOADING)
data TextTextInsertSignalInfo
instance SignalInfo TextTextInsertSignalInfo where
type HaskellCallbackType TextTextInsertSignalInfo = TextTextInsertCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TextTextInsertCallback cb
cb'' <- mk_TextTextInsertCallback cb'
connectSignalFunPtr obj "text-insert" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text::text-insert"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#g:signal:textInsert"})
#endif
type TextTextRemoveCallback =
Int32
-> Int32
-> T.Text
-> IO ()
type C_TextTextRemoveCallback =
Ptr Text ->
Int32 ->
Int32 ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TextTextRemoveCallback :: C_TextTextRemoveCallback -> IO (FunPtr C_TextTextRemoveCallback)
wrap_TextTextRemoveCallback ::
GObject a => (a -> TextTextRemoveCallback) ->
C_TextTextRemoveCallback
wrap_TextTextRemoveCallback :: forall a.
GObject a =>
(a -> TextTextInsertCallback) -> C_TextTextInsertCallback
wrap_TextTextRemoveCallback a -> TextTextInsertCallback
gi'cb Ptr Text
gi'selfPtr Int32
arg1 Int32
arg2 CString
arg3 Ptr ()
_ = do
Text
arg3' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
arg3
Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextTextInsertCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self) Int32
arg1 Int32
arg2 Text
arg3'
onTextTextRemove :: (IsText a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TextTextRemoveCallback) -> m SignalHandlerId
onTextTextRemove :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TextTextInsertCallback)
-> m SignalHandlerId
onTextTextRemove a
obj Maybe Text
detail (?self::a) => TextTextInsertCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextInsertCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextInsertCallback
TextTextInsertCallback
cb
let wrapped' :: C_TextTextInsertCallback
wrapped' = (a -> TextTextInsertCallback) -> C_TextTextInsertCallback
forall a.
GObject a =>
(a -> TextTextInsertCallback) -> C_TextTextInsertCallback
wrap_TextTextRemoveCallback a -> TextTextInsertCallback
wrapped
FunPtr C_TextTextInsertCallback
wrapped'' <- C_TextTextInsertCallback -> IO (FunPtr C_TextTextInsertCallback)
mk_TextTextRemoveCallback C_TextTextInsertCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextInsertCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-remove" FunPtr C_TextTextInsertCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail
afterTextTextRemove :: (IsText a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TextTextRemoveCallback) -> m SignalHandlerId
afterTextTextRemove :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TextTextInsertCallback)
-> m SignalHandlerId
afterTextTextRemove a
obj Maybe Text
detail (?self::a) => TextTextInsertCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> TextTextInsertCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTextInsertCallback
TextTextInsertCallback
cb
let wrapped' :: C_TextTextInsertCallback
wrapped' = (a -> TextTextInsertCallback) -> C_TextTextInsertCallback
forall a.
GObject a =>
(a -> TextTextInsertCallback) -> C_TextTextInsertCallback
wrap_TextTextRemoveCallback a -> TextTextInsertCallback
wrapped
FunPtr C_TextTextInsertCallback
wrapped'' <- C_TextTextInsertCallback -> IO (FunPtr C_TextTextInsertCallback)
mk_TextTextRemoveCallback C_TextTextInsertCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextInsertCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-remove" FunPtr C_TextTextInsertCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail
#if defined(ENABLE_OVERLOADING)
data TextTextRemoveSignalInfo
instance SignalInfo TextTextRemoveSignalInfo where
type HaskellCallbackType TextTextRemoveSignalInfo = TextTextRemoveCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TextTextRemoveCallback cb
cb'' <- mk_TextTextRemoveCallback cb'
connectSignalFunPtr obj "text-remove" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text::text-remove"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#g:signal:textRemove"})
#endif
type TextTextSelectionChangedCallback =
IO ()
type C_TextTextSelectionChangedCallback =
Ptr Text ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_TextTextSelectionChangedCallback :: C_TextTextSelectionChangedCallback -> IO (FunPtr C_TextTextSelectionChangedCallback)
wrap_TextTextSelectionChangedCallback ::
GObject a => (a -> TextTextSelectionChangedCallback) ->
C_TextTextSelectionChangedCallback
wrap_TextTextSelectionChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TextTextAttributesChangedCallback
wrap_TextTextSelectionChangedCallback a -> IO ()
gi'cb Ptr Text
gi'selfPtr Ptr ()
_ = do
Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> IO ()
gi'cb (Text -> a
Coerce.coerce Text
gi'self)
onTextTextSelectionChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextSelectionChangedCallback) -> m SignalHandlerId
onTextTextSelectionChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTextTextSelectionChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TextTextAttributesChangedCallback
wrapped' = (a -> IO ()) -> C_TextTextAttributesChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TextTextAttributesChangedCallback
wrap_TextTextSelectionChangedCallback a -> IO ()
wrapped
FunPtr C_TextTextAttributesChangedCallback
wrapped'' <- C_TextTextAttributesChangedCallback
-> IO (FunPtr C_TextTextAttributesChangedCallback)
mk_TextTextSelectionChangedCallback C_TextTextAttributesChangedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextAttributesChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-selection-changed" FunPtr C_TextTextAttributesChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterTextTextSelectionChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextSelectionChangedCallback) -> m SignalHandlerId
afterTextTextSelectionChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTextTextSelectionChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_TextTextAttributesChangedCallback
wrapped' = (a -> IO ()) -> C_TextTextAttributesChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TextTextAttributesChangedCallback
wrap_TextTextSelectionChangedCallback a -> IO ()
wrapped
FunPtr C_TextTextAttributesChangedCallback
wrapped'' <- C_TextTextAttributesChangedCallback
-> IO (FunPtr C_TextTextAttributesChangedCallback)
mk_TextTextSelectionChangedCallback C_TextTextAttributesChangedCallback
wrapped'
a
-> Text
-> FunPtr C_TextTextAttributesChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-selection-changed" FunPtr C_TextTextAttributesChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data TextTextSelectionChangedSignalInfo
instance SignalInfo TextTextSelectionChangedSignalInfo where
type HaskellCallbackType TextTextSelectionChangedSignalInfo = TextTextSelectionChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_TextTextSelectionChangedCallback cb
cb'' <- mk_TextTextSelectionChangedCallback cb'
connectSignalFunPtr obj "text-selection-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Text::text-selection-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.24/docs/GI-Atk-Interfaces-Text.html#g:signal:textSelectionChanged"})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Text = TextSignalList
type TextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("textAttributesChanged", TextTextAttributesChangedSignalInfo), '("textCaretMoved", TextTextCaretMovedSignalInfo), '("textChanged", TextTextChangedSignalInfo), '("textInsert", TextTextInsertSignalInfo), '("textRemove", TextTextRemoveSignalInfo), '("textSelectionChanged", TextTextSelectionChangedSignalInfo)] :: [(Symbol, *)])
#endif