{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The collection of tags in a @GtkTextBuffer@
-- 
-- You may wish to begin by reading the
-- <https://docs.gtk.org/gtk4/section-text-widget.html text widget conceptual overview>,
-- which gives an overview of all the objects and data types
-- related to the text widget and how they work together.
-- 
-- = GtkTextTagTables as GtkBuildable
-- 
-- The @GtkTextTagTable@ implementation of the @GtkBuildable@ interface
-- supports adding tags by specifying “tag” as the “type” attribute
-- of a \<child> element.
-- 
-- An example of a UI definition fragment specifying tags:
-- 
-- === /xml code/
-- ><object class="GtkTextTagTable">
-- > <child type="tag">
-- >   <object class="GtkTextTag"/>
-- > </child>
-- ></object>
-- 

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Objects.TextTagTable
    ( 

-- * Exported types
    TextTagTable(..)                        ,
    IsTextTagTable                          ,
    toTextTagTable                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [add]("GI.Gtk.Objects.TextTagTable#g:method:add"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Gtk.Objects.TextTagTable#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [lookup]("GI.Gtk.Objects.TextTagTable#g:method:lookup"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.Gtk.Objects.TextTagTable#g:method:remove"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSize]("GI.Gtk.Objects.TextTagTable#g:method:getSize").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveTextTagTableMethod               ,
#endif

-- ** add #method:add#

#if defined(ENABLE_OVERLOADING)
    TextTagTableAddMethodInfo               ,
#endif
    textTagTableAdd                         ,


-- ** foreach #method:foreach#

#if defined(ENABLE_OVERLOADING)
    TextTagTableForeachMethodInfo           ,
#endif
    textTagTableForeach                     ,


-- ** getSize #method:getSize#

#if defined(ENABLE_OVERLOADING)
    TextTagTableGetSizeMethodInfo           ,
#endif
    textTagTableGetSize                     ,


-- ** lookup #method:lookup#

#if defined(ENABLE_OVERLOADING)
    TextTagTableLookupMethodInfo            ,
#endif
    textTagTableLookup                      ,


-- ** new #method:new#

    textTagTableNew                         ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    TextTagTableRemoveMethodInfo            ,
#endif
    textTagTableRemove                      ,




 -- * Signals


-- ** tagAdded #signal:tagAdded#

    TextTagTableTagAddedCallback            ,
#if defined(ENABLE_OVERLOADING)
    TextTagTableTagAddedSignalInfo          ,
#endif
    afterTextTagTableTagAdded               ,
    onTextTagTableTagAdded                  ,


-- ** tagChanged #signal:tagChanged#

    TextTagTableTagChangedCallback          ,
#if defined(ENABLE_OVERLOADING)
    TextTagTableTagChangedSignalInfo        ,
#endif
    afterTextTagTableTagChanged             ,
    onTextTagTableTagChanged                ,


-- ** tagRemoved #signal:tagRemoved#

    TextTagTableTagRemovedCallback          ,
#if defined(ENABLE_OVERLOADING)
    TextTagTableTagRemovedSignalInfo        ,
#endif
    afterTextTagTableTagRemoved             ,
    onTextTagTableTagRemoved                ,




    ) 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.GHashTable as B.GHT
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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTag as Gtk.TextTag

-- | Memory-managed wrapper type.
newtype TextTagTable = TextTagTable (SP.ManagedPtr TextTagTable)
    deriving (TextTagTable -> TextTagTable -> Bool
(TextTagTable -> TextTagTable -> Bool)
-> (TextTagTable -> TextTagTable -> Bool) -> Eq TextTagTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextTagTable -> TextTagTable -> Bool
== :: TextTagTable -> TextTagTable -> Bool
$c/= :: TextTagTable -> TextTagTable -> Bool
/= :: TextTagTable -> TextTagTable -> Bool
Eq)

instance SP.ManagedPtrNewtype TextTagTable where
    toManagedPtr :: TextTagTable -> ManagedPtr TextTagTable
toManagedPtr (TextTagTable ManagedPtr TextTagTable
p) = ManagedPtr TextTagTable
p

foreign import ccall "gtk_text_tag_table_get_type"
    c_gtk_text_tag_table_get_type :: IO B.Types.GType

instance B.Types.TypedObject TextTagTable where
    glibType :: IO GType
glibType = IO GType
c_gtk_text_tag_table_get_type

instance B.Types.GObject TextTagTable

-- | Type class for types which can be safely cast to `TextTagTable`, for instance with `toTextTagTable`.
class (SP.GObject o, O.IsDescendantOf TextTagTable o) => IsTextTagTable o
instance (SP.GObject o, O.IsDescendantOf TextTagTable o) => IsTextTagTable o

instance O.HasParentTypes TextTagTable
type instance O.ParentTypes TextTagTable = '[GObject.Object.Object, Gtk.Buildable.Buildable]

-- | Cast to `TextTagTable`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTextTagTable :: (MIO.MonadIO m, IsTextTagTable o) => o -> m TextTagTable
toTextTagTable :: forall (m :: * -> *) o.
(MonadIO m, IsTextTagTable o) =>
o -> m TextTagTable
toTextTagTable = IO TextTagTable -> m TextTagTable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TextTagTable -> m TextTagTable)
-> (o -> IO TextTagTable) -> o -> m TextTagTable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TextTagTable -> TextTagTable) -> o -> IO TextTagTable
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TextTagTable -> TextTagTable
TextTagTable

-- | Convert 'TextTagTable' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe TextTagTable) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_text_tag_table_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TextTagTable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TextTagTable
P.Nothing = Ptr GValue -> Ptr TextTagTable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TextTagTable
forall a. Ptr a
FP.nullPtr :: FP.Ptr TextTagTable)
    gvalueSet_ Ptr GValue
gv (P.Just TextTagTable
obj) = TextTagTable -> (Ptr TextTagTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TextTagTable
obj (Ptr GValue -> Ptr TextTagTable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TextTagTable)
gvalueGet_ Ptr GValue
gv = do
        Ptr TextTagTable
ptr <- Ptr GValue -> IO (Ptr TextTagTable)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TextTagTable)
        if Ptr TextTagTable
ptr Ptr TextTagTable -> Ptr TextTagTable -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TextTagTable
forall a. Ptr a
FP.nullPtr
        then TextTagTable -> Maybe TextTagTable
forall a. a -> Maybe a
P.Just (TextTagTable -> Maybe TextTagTable)
-> IO TextTagTable -> IO (Maybe TextTagTable)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TextTagTable -> TextTagTable)
-> Ptr TextTagTable -> IO TextTagTable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TextTagTable -> TextTagTable
TextTagTable Ptr TextTagTable
ptr
        else Maybe TextTagTable -> IO (Maybe TextTagTable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TextTagTable
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTextTagTableMethod (t :: Symbol) (o :: *) :: * where
    ResolveTextTagTableMethod "add" o = TextTagTableAddMethodInfo
    ResolveTextTagTableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTextTagTableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTextTagTableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTextTagTableMethod "foreach" o = TextTagTableForeachMethodInfo
    ResolveTextTagTableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTextTagTableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTextTagTableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTextTagTableMethod "lookup" o = TextTagTableLookupMethodInfo
    ResolveTextTagTableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTextTagTableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTextTagTableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTextTagTableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTextTagTableMethod "remove" o = TextTagTableRemoveMethodInfo
    ResolveTextTagTableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTextTagTableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTextTagTableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTextTagTableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTextTagTableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTextTagTableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTextTagTableMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveTextTagTableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTextTagTableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTextTagTableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTextTagTableMethod "getSize" o = TextTagTableGetSizeMethodInfo
    ResolveTextTagTableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTextTagTableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTextTagTableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTextTagTableMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTextTagTableMethod t TextTagTable, O.OverloadedMethod info TextTagTable p) => OL.IsLabel t (TextTagTable -> 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 ~ ResolveTextTagTableMethod t TextTagTable, O.OverloadedMethod info TextTagTable p, R.HasField t TextTagTable p) => R.HasField t TextTagTable p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTextTagTableMethod t TextTagTable, O.OverloadedMethodInfo info TextTagTable) => OL.IsLabel t (O.MethodProxy info TextTagTable) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal TextTagTable::tag-added
-- | Emitted every time a new tag is added in the @GtkTextTagTable@.
type TextTagTableTagAddedCallback =
    Gtk.TextTag.TextTag
    -- ^ /@tag@/: the added tag.
    -> IO ()

type C_TextTagTableTagAddedCallback =
    Ptr TextTagTable ->                     -- object
    Ptr Gtk.TextTag.TextTag ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TextTagTableTagAddedCallback`.
foreign import ccall "wrapper"
    mk_TextTagTableTagAddedCallback :: C_TextTagTableTagAddedCallback -> IO (FunPtr C_TextTagTableTagAddedCallback)

wrap_TextTagTableTagAddedCallback :: 
    GObject a => (a -> TextTagTableTagAddedCallback) ->
    C_TextTagTableTagAddedCallback
wrap_TextTagTableTagAddedCallback :: forall a.
GObject a =>
(a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
wrap_TextTagTableTagAddedCallback a -> TextTagTableTagAddedCallback
gi'cb Ptr TextTagTable
gi'selfPtr Ptr TextTag
tag Ptr ()
_ = do
    TextTag
tag' <- ((ManagedPtr TextTag -> TextTag) -> Ptr TextTag -> IO TextTag
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextTag -> TextTag
Gtk.TextTag.TextTag) Ptr TextTag
tag
    Ptr TextTagTable -> (TextTagTable -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TextTagTable
gi'selfPtr ((TextTagTable -> IO ()) -> IO ())
-> (TextTagTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextTagTable
gi'self -> a -> TextTagTableTagAddedCallback
gi'cb (TextTagTable -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TextTagTable
gi'self)  TextTag
tag'


-- | Connect a signal handler for the [tagAdded](#signal:tagAdded) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' textTagTable #tagAdded callback
-- @
-- 
-- 
onTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId
onTextTagTableTagAdded :: forall a (m :: * -> *).
(IsTextTagTable a, MonadIO m) =>
a
-> ((?self::a) => TextTagTableTagAddedCallback)
-> m SignalHandlerId
onTextTagTableTagAdded a
obj (?self::a) => TextTagTableTagAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> TextTagTableTagAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTagTableTagAddedCallback
TextTagTableTagAddedCallback
cb
    let wrapped' :: C_TextTagTableTagAddedCallback
wrapped' = (a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
forall a.
GObject a =>
(a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
wrap_TextTagTableTagAddedCallback a -> TextTagTableTagAddedCallback
wrapped
    FunPtr C_TextTagTableTagAddedCallback
wrapped'' <- C_TextTagTableTagAddedCallback
-> IO (FunPtr C_TextTagTableTagAddedCallback)
mk_TextTagTableTagAddedCallback C_TextTagTableTagAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextTagTableTagAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"tag-added" FunPtr C_TextTagTableTagAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [tagAdded](#signal:tagAdded) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' textTagTable #tagAdded callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId
afterTextTagTableTagAdded :: forall a (m :: * -> *).
(IsTextTagTable a, MonadIO m) =>
a
-> ((?self::a) => TextTagTableTagAddedCallback)
-> m SignalHandlerId
afterTextTagTableTagAdded a
obj (?self::a) => TextTagTableTagAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> TextTagTableTagAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTagTableTagAddedCallback
TextTagTableTagAddedCallback
cb
    let wrapped' :: C_TextTagTableTagAddedCallback
wrapped' = (a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
forall a.
GObject a =>
(a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
wrap_TextTagTableTagAddedCallback a -> TextTagTableTagAddedCallback
wrapped
    FunPtr C_TextTagTableTagAddedCallback
wrapped'' <- C_TextTagTableTagAddedCallback
-> IO (FunPtr C_TextTagTableTagAddedCallback)
mk_TextTagTableTagAddedCallback C_TextTagTableTagAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextTagTableTagAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"tag-added" FunPtr C_TextTagTableTagAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextTagTableTagAddedSignalInfo
instance SignalInfo TextTagTableTagAddedSignalInfo where
    type HaskellCallbackType TextTagTableTagAddedSignalInfo = TextTagTableTagAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextTagTableTagAddedCallback cb
        cb'' <- mk_TextTagTableTagAddedCallback cb'
        connectSignalFunPtr obj "tag-added" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable::tag-added"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#g:signal:tagAdded"})

#endif

-- signal TextTagTable::tag-changed
-- | Emitted every time a tag in the @GtkTextTagTable@ changes.
type TextTagTableTagChangedCallback =
    Gtk.TextTag.TextTag
    -- ^ /@tag@/: the changed tag.
    -> Bool
    -- ^ /@sizeChanged@/: whether the change affects the @GtkTextView@ layout.
    -> IO ()

type C_TextTagTableTagChangedCallback =
    Ptr TextTagTable ->                     -- object
    Ptr Gtk.TextTag.TextTag ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TextTagTableTagChangedCallback`.
foreign import ccall "wrapper"
    mk_TextTagTableTagChangedCallback :: C_TextTagTableTagChangedCallback -> IO (FunPtr C_TextTagTableTagChangedCallback)

wrap_TextTagTableTagChangedCallback :: 
    GObject a => (a -> TextTagTableTagChangedCallback) ->
    C_TextTagTableTagChangedCallback
wrap_TextTagTableTagChangedCallback :: forall a.
GObject a =>
(a -> TextTagTableTagChangedCallback)
-> C_TextTagTableTagChangedCallback
wrap_TextTagTableTagChangedCallback a -> TextTagTableTagChangedCallback
gi'cb Ptr TextTagTable
gi'selfPtr Ptr TextTag
tag CInt
sizeChanged Ptr ()
_ = do
    TextTag
tag' <- ((ManagedPtr TextTag -> TextTag) -> Ptr TextTag -> IO TextTag
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextTag -> TextTag
Gtk.TextTag.TextTag) Ptr TextTag
tag
    let sizeChanged' :: Bool
sizeChanged' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
sizeChanged
    Ptr TextTagTable -> (TextTagTable -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TextTagTable
gi'selfPtr ((TextTagTable -> IO ()) -> IO ())
-> (TextTagTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextTagTable
gi'self -> a -> TextTagTableTagChangedCallback
gi'cb (TextTagTable -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TextTagTable
gi'self)  TextTag
tag' Bool
sizeChanged'


-- | Connect a signal handler for the [tagChanged](#signal:tagChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' textTagTable #tagChanged callback
-- @
-- 
-- 
onTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId
onTextTagTableTagChanged :: forall a (m :: * -> *).
(IsTextTagTable a, MonadIO m) =>
a
-> ((?self::a) => TextTagTableTagChangedCallback)
-> m SignalHandlerId
onTextTagTableTagChanged a
obj (?self::a) => TextTagTableTagChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> TextTagTableTagChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTagTableTagChangedCallback
TextTagTableTagChangedCallback
cb
    let wrapped' :: C_TextTagTableTagChangedCallback
wrapped' = (a -> TextTagTableTagChangedCallback)
-> C_TextTagTableTagChangedCallback
forall a.
GObject a =>
(a -> TextTagTableTagChangedCallback)
-> C_TextTagTableTagChangedCallback
wrap_TextTagTableTagChangedCallback a -> TextTagTableTagChangedCallback
wrapped
    FunPtr C_TextTagTableTagChangedCallback
wrapped'' <- C_TextTagTableTagChangedCallback
-> IO (FunPtr C_TextTagTableTagChangedCallback)
mk_TextTagTableTagChangedCallback C_TextTagTableTagChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextTagTableTagChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"tag-changed" FunPtr C_TextTagTableTagChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [tagChanged](#signal:tagChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' textTagTable #tagChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId
afterTextTagTableTagChanged :: forall a (m :: * -> *).
(IsTextTagTable a, MonadIO m) =>
a
-> ((?self::a) => TextTagTableTagChangedCallback)
-> m SignalHandlerId
afterTextTagTableTagChanged a
obj (?self::a) => TextTagTableTagChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> TextTagTableTagChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTagTableTagChangedCallback
TextTagTableTagChangedCallback
cb
    let wrapped' :: C_TextTagTableTagChangedCallback
wrapped' = (a -> TextTagTableTagChangedCallback)
-> C_TextTagTableTagChangedCallback
forall a.
GObject a =>
(a -> TextTagTableTagChangedCallback)
-> C_TextTagTableTagChangedCallback
wrap_TextTagTableTagChangedCallback a -> TextTagTableTagChangedCallback
wrapped
    FunPtr C_TextTagTableTagChangedCallback
wrapped'' <- C_TextTagTableTagChangedCallback
-> IO (FunPtr C_TextTagTableTagChangedCallback)
mk_TextTagTableTagChangedCallback C_TextTagTableTagChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextTagTableTagChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"tag-changed" FunPtr C_TextTagTableTagChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextTagTableTagChangedSignalInfo
instance SignalInfo TextTagTableTagChangedSignalInfo where
    type HaskellCallbackType TextTagTableTagChangedSignalInfo = TextTagTableTagChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextTagTableTagChangedCallback cb
        cb'' <- mk_TextTagTableTagChangedCallback cb'
        connectSignalFunPtr obj "tag-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable::tag-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#g:signal:tagChanged"})

#endif

-- signal TextTagTable::tag-removed
-- | Emitted every time a tag is removed from the @GtkTextTagTable@.
-- 
-- The /@tag@/ is still valid by the time the signal is emitted, but
-- it is not associated with a tag table any more.
type TextTagTableTagRemovedCallback =
    Gtk.TextTag.TextTag
    -- ^ /@tag@/: the removed tag.
    -> IO ()

type C_TextTagTableTagRemovedCallback =
    Ptr TextTagTable ->                     -- object
    Ptr Gtk.TextTag.TextTag ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TextTagTableTagRemovedCallback`.
foreign import ccall "wrapper"
    mk_TextTagTableTagRemovedCallback :: C_TextTagTableTagRemovedCallback -> IO (FunPtr C_TextTagTableTagRemovedCallback)

wrap_TextTagTableTagRemovedCallback :: 
    GObject a => (a -> TextTagTableTagRemovedCallback) ->
    C_TextTagTableTagRemovedCallback
wrap_TextTagTableTagRemovedCallback :: forall a.
GObject a =>
(a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
wrap_TextTagTableTagRemovedCallback a -> TextTagTableTagAddedCallback
gi'cb Ptr TextTagTable
gi'selfPtr Ptr TextTag
tag Ptr ()
_ = do
    TextTag
tag' <- ((ManagedPtr TextTag -> TextTag) -> Ptr TextTag -> IO TextTag
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextTag -> TextTag
Gtk.TextTag.TextTag) Ptr TextTag
tag
    Ptr TextTagTable -> (TextTagTable -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TextTagTable
gi'selfPtr ((TextTagTable -> IO ()) -> IO ())
-> (TextTagTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextTagTable
gi'self -> a -> TextTagTableTagAddedCallback
gi'cb (TextTagTable -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TextTagTable
gi'self)  TextTag
tag'


-- | Connect a signal handler for the [tagRemoved](#signal:tagRemoved) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' textTagTable #tagRemoved callback
-- @
-- 
-- 
onTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId
onTextTagTableTagRemoved :: forall a (m :: * -> *).
(IsTextTagTable a, MonadIO m) =>
a
-> ((?self::a) => TextTagTableTagAddedCallback)
-> m SignalHandlerId
onTextTagTableTagRemoved a
obj (?self::a) => TextTagTableTagAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> TextTagTableTagAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTagTableTagAddedCallback
TextTagTableTagAddedCallback
cb
    let wrapped' :: C_TextTagTableTagAddedCallback
wrapped' = (a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
forall a.
GObject a =>
(a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
wrap_TextTagTableTagRemovedCallback a -> TextTagTableTagAddedCallback
wrapped
    FunPtr C_TextTagTableTagAddedCallback
wrapped'' <- C_TextTagTableTagAddedCallback
-> IO (FunPtr C_TextTagTableTagAddedCallback)
mk_TextTagTableTagRemovedCallback C_TextTagTableTagAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextTagTableTagAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"tag-removed" FunPtr C_TextTagTableTagAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [tagRemoved](#signal:tagRemoved) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' textTagTable #tagRemoved callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId
afterTextTagTableTagRemoved :: forall a (m :: * -> *).
(IsTextTagTable a, MonadIO m) =>
a
-> ((?self::a) => TextTagTableTagAddedCallback)
-> m SignalHandlerId
afterTextTagTableTagRemoved a
obj (?self::a) => TextTagTableTagAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> TextTagTableTagAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextTagTableTagAddedCallback
TextTagTableTagAddedCallback
cb
    let wrapped' :: C_TextTagTableTagAddedCallback
wrapped' = (a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
forall a.
GObject a =>
(a -> TextTagTableTagAddedCallback)
-> C_TextTagTableTagAddedCallback
wrap_TextTagTableTagRemovedCallback a -> TextTagTableTagAddedCallback
wrapped
    FunPtr C_TextTagTableTagAddedCallback
wrapped'' <- C_TextTagTableTagAddedCallback
-> IO (FunPtr C_TextTagTableTagAddedCallback)
mk_TextTagTableTagRemovedCallback C_TextTagTableTagAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextTagTableTagAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"tag-removed" FunPtr C_TextTagTableTagAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextTagTableTagRemovedSignalInfo
instance SignalInfo TextTagTableTagRemovedSignalInfo where
    type HaskellCallbackType TextTagTableTagRemovedSignalInfo = TextTagTableTagRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextTagTableTagRemovedCallback cb
        cb'' <- mk_TextTagTableTagRemovedCallback cb'
        connectSignalFunPtr obj "tag-removed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable::tag-removed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#g:signal:tagRemoved"})

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TextTagTable
type instance O.AttributeList TextTagTable = TextTagTableAttributeList
type TextTagTableAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TextTagTable = TextTagTableSignalList
type TextTagTableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("tagAdded", TextTagTableTagAddedSignalInfo), '("tagChanged", TextTagTableTagChangedSignalInfo), '("tagRemoved", TextTagTableTagRemovedSignalInfo)] :: [(Symbol, *)])

#endif

-- method TextTagTable::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "TextTagTable" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_tag_table_new" gtk_text_tag_table_new :: 
    IO (Ptr TextTagTable)

-- | Creates a new @GtkTextTagTable@.
-- 
-- The table contains no tags by default.
textTagTableNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TextTagTable
    -- ^ __Returns:__ a new @GtkTextTagTable@
textTagTableNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TextTagTable
textTagTableNew  = IO TextTagTable -> m TextTagTable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextTagTable -> m TextTagTable)
-> IO TextTagTable -> m TextTagTable
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextTagTable
result <- IO (Ptr TextTagTable)
gtk_text_tag_table_new
    Text -> Ptr TextTagTable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textTagTableNew" Ptr TextTagTable
result
    TextTagTable
result' <- ((ManagedPtr TextTagTable -> TextTagTable)
-> Ptr TextTagTable -> IO TextTagTable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TextTagTable -> TextTagTable
TextTagTable) Ptr TextTagTable
result
    TextTagTable -> IO TextTagTable
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextTagTable
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method TextTagTable::add
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTagTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTagTable`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTag" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTag`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_tag_table_add" gtk_text_tag_table_add :: 
    Ptr TextTagTable ->                     -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
    Ptr Gtk.TextTag.TextTag ->              -- tag : TInterface (Name {namespace = "Gtk", name = "TextTag"})
    IO CInt

-- | Add a tag to the table.
-- 
-- The tag is assigned the highest priority in the table.
-- 
-- /@tag@/ must not be in a tag table already, and may not have
-- the same name as an already-added tag.
textTagTableAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextTagTable a, Gtk.TextTag.IsTextTag b) =>
    a
    -- ^ /@table@/: a @GtkTextTagTable@
    -> b
    -- ^ /@tag@/: a @GtkTextTag@
    -> m Bool
    -- ^ __Returns:__ 'P.True' on success.
textTagTableAdd :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTextTagTable a, IsTextTag b) =>
a -> b -> m Bool
textTagTableAdd a
table b
tag = IO Bool -> m Bool
forall a. IO a -> m a
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 TextTagTable
table' <- a -> IO (Ptr TextTagTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
    Ptr TextTag
tag' <- b -> IO (Ptr TextTag)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
tag
    CInt
result <- Ptr TextTagTable -> Ptr TextTag -> IO CInt
gtk_text_tag_table_add Ptr TextTagTable
table' Ptr TextTag
tag'
    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
table
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
tag
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextTagTableAddMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTextTagTable a, Gtk.TextTag.IsTextTag b) => O.OverloadedMethod TextTagTableAddMethodInfo a signature where
    overloadedMethod = textTagTableAdd

instance O.OverloadedMethodInfo TextTagTableAddMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable.textTagTableAdd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#v:textTagTableAdd"
        })


#endif

-- method TextTagTable::foreach
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTagTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTagTable`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "TextTagTableForeach" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a function to call on each tag"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_tag_table_foreach" gtk_text_tag_table_foreach :: 
    Ptr TextTagTable ->                     -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
    FunPtr Gtk.Callbacks.C_TextTagTableForeach -> -- func : TInterface (Name {namespace = "Gtk", name = "TextTagTableForeach"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

-- | Calls /@func@/ on each tag in /@table@/, with user data /@data@/.
-- 
-- Note that the table may not be modified while iterating
-- over it (you can’t add\/remove tags).
textTagTableForeach ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextTagTable a) =>
    a
    -- ^ /@table@/: a @GtkTextTagTable@
    -> Gtk.Callbacks.TextTagTableForeach
    -- ^ /@func@/: a function to call on each tag
    -> m ()
textTagTableForeach :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextTagTable a) =>
a -> TextTagTableTagAddedCallback -> m ()
textTagTableForeach a
table TextTagTableTagAddedCallback
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextTagTable
table' <- a -> IO (Ptr TextTagTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
    FunPtr C_TextTagTableForeach
func' <- C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)
Gtk.Callbacks.mk_TextTagTableForeach (Maybe (Ptr (FunPtr C_TextTagTableForeach))
-> TextTagTableForeach_WithClosures -> C_TextTagTableForeach
Gtk.Callbacks.wrap_TextTagTableForeach Maybe (Ptr (FunPtr C_TextTagTableForeach))
forall a. Maybe a
Nothing (TextTagTableTagAddedCallback -> TextTagTableForeach_WithClosures
Gtk.Callbacks.drop_closures_TextTagTableForeach TextTagTableTagAddedCallback
func))
    let data_ :: Ptr a
data_ = Ptr a
forall a. Ptr a
nullPtr
    Ptr TextTagTable -> FunPtr C_TextTagTableForeach -> Ptr () -> IO ()
gtk_text_tag_table_foreach Ptr TextTagTable
table' FunPtr C_TextTagTableForeach
func' Ptr ()
forall a. Ptr a
data_
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_TextTagTableForeach -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TextTagTableForeach
func'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextTagTableForeachMethodInfo
instance (signature ~ (Gtk.Callbacks.TextTagTableForeach -> m ()), MonadIO m, IsTextTagTable a) => O.OverloadedMethod TextTagTableForeachMethodInfo a signature where
    overloadedMethod = textTagTableForeach

instance O.OverloadedMethodInfo TextTagTableForeachMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable.textTagTableForeach",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#v:textTagTableForeach"
        })


#endif

-- method TextTagTable::get_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTagTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTagTable`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_tag_table_get_size" gtk_text_tag_table_get_size :: 
    Ptr TextTagTable ->                     -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
    IO Int32

-- | Returns the size of the table (number of tags)
textTagTableGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextTagTable a) =>
    a
    -- ^ /@table@/: a @GtkTextTagTable@
    -> m Int32
    -- ^ __Returns:__ number of tags in /@table@/
textTagTableGetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextTagTable a) =>
a -> m Int32
textTagTableGetSize a
table = IO Int32 -> m Int32
forall a. IO a -> m a
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 TextTagTable
table' <- a -> IO (Ptr TextTagTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
    Int32
result <- Ptr TextTagTable -> IO Int32
gtk_text_tag_table_get_size Ptr TextTagTable
table'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TextTagTableGetSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTextTagTable a) => O.OverloadedMethod TextTagTableGetSizeMethodInfo a signature where
    overloadedMethod = textTagTableGetSize

instance O.OverloadedMethodInfo TextTagTableGetSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable.textTagTableGetSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#v:textTagTableGetSize"
        })


#endif

-- method TextTagTable::lookup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTagTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTagTable`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of a tag" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "TextTag" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_tag_table_lookup" gtk_text_tag_table_lookup :: 
    Ptr TextTagTable ->                     -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Gtk.TextTag.TextTag)

-- | Look up a named tag.
textTagTableLookup ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextTagTable a) =>
    a
    -- ^ /@table@/: a @GtkTextTagTable@
    -> T.Text
    -- ^ /@name@/: name of a tag
    -> m (Maybe Gtk.TextTag.TextTag)
    -- ^ __Returns:__ The tag
textTagTableLookup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextTagTable a) =>
a -> Text -> m (Maybe TextTag)
textTagTableLookup a
table Text
name = IO (Maybe TextTag) -> m (Maybe TextTag)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TextTag) -> m (Maybe TextTag))
-> IO (Maybe TextTag) -> m (Maybe TextTag)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextTagTable
table' <- a -> IO (Ptr TextTagTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr TextTag
result <- Ptr TextTagTable -> CString -> IO (Ptr TextTag)
gtk_text_tag_table_lookup Ptr TextTagTable
table' CString
name'
    Maybe TextTag
maybeResult <- Ptr TextTag -> (Ptr TextTag -> IO TextTag) -> IO (Maybe TextTag)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TextTag
result ((Ptr TextTag -> IO TextTag) -> IO (Maybe TextTag))
-> (Ptr TextTag -> IO TextTag) -> IO (Maybe TextTag)
forall a b. (a -> b) -> a -> b
$ \Ptr TextTag
result' -> do
        TextTag
result'' <- ((ManagedPtr TextTag -> TextTag) -> Ptr TextTag -> IO TextTag
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextTag -> TextTag
Gtk.TextTag.TextTag) Ptr TextTag
result'
        TextTag -> IO TextTag
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextTag
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Maybe TextTag -> IO (Maybe TextTag)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TextTag
maybeResult

#if defined(ENABLE_OVERLOADING)
data TextTagTableLookupMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gtk.TextTag.TextTag)), MonadIO m, IsTextTagTable a) => O.OverloadedMethod TextTagTableLookupMethodInfo a signature where
    overloadedMethod = textTagTableLookup

instance O.OverloadedMethodInfo TextTagTableLookupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable.textTagTableLookup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#v:textTagTableLookup"
        })


#endif

-- method TextTagTable::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTagTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTagTable`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTag" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkTextTag`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_tag_table_remove" gtk_text_tag_table_remove :: 
    Ptr TextTagTable ->                     -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
    Ptr Gtk.TextTag.TextTag ->              -- tag : TInterface (Name {namespace = "Gtk", name = "TextTag"})
    IO ()

-- | Remove a tag from the table.
-- 
-- If a @GtkTextBuffer@ has /@table@/ as its tag table, the tag is
-- removed from the buffer. The table’s reference to the tag is
-- removed, so the tag will end up destroyed if you don’t have
-- a reference to it.
textTagTableRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextTagTable a, Gtk.TextTag.IsTextTag b) =>
    a
    -- ^ /@table@/: a @GtkTextTagTable@
    -> b
    -- ^ /@tag@/: a @GtkTextTag@
    -> m ()
textTagTableRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTextTagTable a, IsTextTag b) =>
a -> b -> m ()
textTagTableRemove a
table b
tag = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextTagTable
table' <- a -> IO (Ptr TextTagTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
    Ptr TextTag
tag' <- b -> IO (Ptr TextTag)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
tag
    Ptr TextTagTable -> Ptr TextTag -> IO ()
gtk_text_tag_table_remove Ptr TextTagTable
table' Ptr TextTag
tag'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
table
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
tag
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextTagTableRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTextTagTable a, Gtk.TextTag.IsTextTag b) => O.OverloadedMethod TextTagTableRemoveMethodInfo a signature where
    overloadedMethod = textTagTableRemove

instance O.OverloadedMethodInfo TextTagTableRemoveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.TextTagTable.textTagTableRemove",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-TextTagTable.html#v:textTagTableRemove"
        })


#endif