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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Dazzle.Objects.TreeBuilder
    ( 

-- * Exported types
    TreeBuilder(..)                         ,
    IsTreeBuilder                           ,
    toTreeBuilder                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [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"), [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
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getTree]("GI.Dazzle.Objects.TreeBuilder#g:method:getTree").
-- 
-- ==== 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)
    ResolveTreeBuilderMethod                ,
#endif

-- ** getTree #method:getTree#

#if defined(ENABLE_OVERLOADING)
    TreeBuilderGetTreeMethodInfo            ,
#endif
    treeBuilderGetTree                      ,


-- ** new #method:new#

    treeBuilderNew                          ,




 -- * Properties


-- ** tree #attr:tree#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeBuilderTreePropertyInfo             ,
#endif
    getTreeBuilderTree                      ,
#if defined(ENABLE_OVERLOADING)
    treeBuilderTree                         ,
#endif




 -- * Signals


-- ** added #signal:added#

    TreeBuilderAddedCallback                ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderAddedSignalInfo              ,
#endif
    afterTreeBuilderAdded                   ,
    onTreeBuilderAdded                      ,


-- ** buildChildren #signal:buildChildren#

    TreeBuilderBuildChildrenCallback        ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderBuildChildrenSignalInfo      ,
#endif
    afterTreeBuilderBuildChildren           ,
    onTreeBuilderBuildChildren              ,


-- ** buildNode #signal:buildNode#

    TreeBuilderBuildNodeCallback            ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderBuildNodeSignalInfo          ,
#endif
    afterTreeBuilderBuildNode               ,
    onTreeBuilderBuildNode                  ,


-- ** dragDataGet #signal:dragDataGet#

    TreeBuilderDragDataGetCallback          ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderDragDataGetSignalInfo        ,
#endif
    afterTreeBuilderDragDataGet             ,
    onTreeBuilderDragDataGet                ,


-- ** dragDataReceived #signal:dragDataReceived#

    TreeBuilderDragDataReceivedCallback     ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderDragDataReceivedSignalInfo   ,
#endif
    afterTreeBuilderDragDataReceived        ,
    onTreeBuilderDragDataReceived           ,


-- ** dragNodeDelete #signal:dragNodeDelete#

    TreeBuilderDragNodeDeleteCallback       ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderDragNodeDeleteSignalInfo     ,
#endif
    afterTreeBuilderDragNodeDelete          ,
    onTreeBuilderDragNodeDelete             ,


-- ** dragNodeReceived #signal:dragNodeReceived#

    TreeBuilderDragNodeReceivedCallback     ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderDragNodeReceivedSignalInfo   ,
#endif
    afterTreeBuilderDragNodeReceived        ,
    onTreeBuilderDragNodeReceived           ,


-- ** nodeActivated #signal:nodeActivated#

    TreeBuilderNodeActivatedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeActivatedSignalInfo      ,
#endif
    afterTreeBuilderNodeActivated           ,
    onTreeBuilderNodeActivated              ,


-- ** nodeCollapsed #signal:nodeCollapsed#

    TreeBuilderNodeCollapsedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeCollapsedSignalInfo      ,
#endif
    afterTreeBuilderNodeCollapsed           ,
    onTreeBuilderNodeCollapsed              ,


-- ** nodeDraggable #signal:nodeDraggable#

    TreeBuilderNodeDraggableCallback        ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeDraggableSignalInfo      ,
#endif
    afterTreeBuilderNodeDraggable           ,
    onTreeBuilderNodeDraggable              ,


-- ** nodeDroppable #signal:nodeDroppable#

    TreeBuilderNodeDroppableCallback        ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeDroppableSignalInfo      ,
#endif
    afterTreeBuilderNodeDroppable           ,
    onTreeBuilderNodeDroppable              ,


-- ** nodeExpanded #signal:nodeExpanded#

    TreeBuilderNodeExpandedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeExpandedSignalInfo       ,
#endif
    afterTreeBuilderNodeExpanded            ,
    onTreeBuilderNodeExpanded               ,


-- ** nodePopup #signal:nodePopup#

    TreeBuilderNodePopupCallback            ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodePopupSignalInfo          ,
#endif
    afterTreeBuilderNodePopup               ,
    onTreeBuilderNodePopup                  ,


-- ** nodeSelected #signal:nodeSelected#

    TreeBuilderNodeSelectedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeSelectedSignalInfo       ,
#endif
    afterTreeBuilderNodeSelected            ,
    onTreeBuilderNodeSelected               ,


-- ** nodeUnselected #signal:nodeUnselected#

    TreeBuilderNodeUnselectedCallback       ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderNodeUnselectedSignalInfo     ,
#endif
    afterTreeBuilderNodeUnselected          ,
    onTreeBuilderNodeUnselected             ,


-- ** removed #signal:removed#

    TreeBuilderRemovedCallback              ,
#if defined(ENABLE_OVERLOADING)
    TreeBuilderRemovedSignalInfo            ,
#endif
    afterTreeBuilderRemoved                 ,
    onTreeBuilderRemoved                    ,




    ) 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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import {-# SOURCE #-} qualified GI.Dazzle.Enums as Dazzle.Enums
import {-# SOURCE #-} qualified GI.Dazzle.Objects.Tree as Dazzle.Tree
import {-# SOURCE #-} qualified GI.Dazzle.Objects.TreeNode as Dazzle.TreeNode
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Objects.Menu as Gio.Menu
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Popover as Gtk.Popover
import qualified GI.Gtk.Objects.TreeView as Gtk.TreeView
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData
import qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter
import qualified GI.Gtk.Structs.TreePath as Gtk.TreePath

#else
import {-# SOURCE #-} qualified GI.Dazzle.Enums as Dazzle.Enums
import {-# SOURCE #-} qualified GI.Dazzle.Objects.Tree as Dazzle.Tree
import {-# SOURCE #-} qualified GI.Dazzle.Objects.TreeNode as Dazzle.TreeNode
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gio.Objects.Menu as Gio.Menu
import qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData

#endif

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

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

foreign import ccall "dzl_tree_builder_get_type"
    c_dzl_tree_builder_get_type :: IO B.Types.GType

instance B.Types.TypedObject TreeBuilder where
    glibType :: IO GType
glibType = IO GType
c_dzl_tree_builder_get_type

instance B.Types.GObject TreeBuilder

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

instance O.HasParentTypes TreeBuilder
type instance O.ParentTypes TreeBuilder = '[GObject.Object.Object]

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

-- | Convert 'TreeBuilder' 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 TreeBuilder) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_tree_builder_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TreeBuilder -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TreeBuilder
P.Nothing = Ptr GValue -> Ptr TreeBuilder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TreeBuilder
forall a. Ptr a
FP.nullPtr :: FP.Ptr TreeBuilder)
    gvalueSet_ Ptr GValue
gv (P.Just TreeBuilder
obj) = TreeBuilder -> (Ptr TreeBuilder -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeBuilder
obj (Ptr GValue -> Ptr TreeBuilder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TreeBuilder)
gvalueGet_ Ptr GValue
gv = do
        Ptr TreeBuilder
ptr <- Ptr GValue -> IO (Ptr TreeBuilder)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TreeBuilder)
        if Ptr TreeBuilder
ptr Ptr TreeBuilder -> Ptr TreeBuilder -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TreeBuilder
forall a. Ptr a
FP.nullPtr
        then TreeBuilder -> Maybe TreeBuilder
forall a. a -> Maybe a
P.Just (TreeBuilder -> Maybe TreeBuilder)
-> IO TreeBuilder -> IO (Maybe TreeBuilder)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TreeBuilder -> TreeBuilder)
-> Ptr TreeBuilder -> IO TreeBuilder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TreeBuilder -> TreeBuilder
TreeBuilder Ptr TreeBuilder
ptr
        else Maybe TreeBuilder -> IO (Maybe TreeBuilder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeBuilder
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTreeBuilderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveTreeBuilderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeBuilderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeBuilderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeBuilderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeBuilderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTreeBuilderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeBuilderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeBuilderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeBuilderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeBuilderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeBuilderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeBuilderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeBuilderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeBuilderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeBuilderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeBuilderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeBuilderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeBuilderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeBuilderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeBuilderMethod "getTree" o = TreeBuilderGetTreeMethodInfo
    ResolveTreeBuilderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeBuilderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTreeBuilderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeBuilderMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal TreeBuilder::added
-- | /No description available in the introspection data./
type TreeBuilderAddedCallback =
    Dazzle.Tree.Tree
    -> IO ()

type C_TreeBuilderAddedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.Tree.Tree ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderAddedCallback :: 
    GObject a => (a -> TreeBuilderAddedCallback) ->
    C_TreeBuilderAddedCallback
wrap_TreeBuilderAddedCallback :: forall a.
GObject a =>
(a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
wrap_TreeBuilderAddedCallback a -> TreeBuilderAddedCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr Tree
object Ptr ()
_ = do
    Tree
object' <- ((ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Tree -> Tree
Dazzle.Tree.Tree) Ptr Tree
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderAddedCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  Tree
object'


-- | Connect a signal handler for the [added](#signal:added) 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' treeBuilder #added callback
-- @
-- 
-- 
onTreeBuilderAdded :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderAddedCallback) -> m SignalHandlerId
onTreeBuilderAdded :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a -> ((?self::a) => TreeBuilderAddedCallback) -> m SignalHandlerId
onTreeBuilderAdded a
obj (?self::a) => TreeBuilderAddedCallback
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 -> TreeBuilderAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderAddedCallback
TreeBuilderAddedCallback
cb
    let wrapped' :: C_TreeBuilderAddedCallback
wrapped' = (a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
forall a.
GObject a =>
(a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
wrap_TreeBuilderAddedCallback a -> TreeBuilderAddedCallback
wrapped
    FunPtr C_TreeBuilderAddedCallback
wrapped'' <- C_TreeBuilderAddedCallback
-> IO (FunPtr C_TreeBuilderAddedCallback)
mk_TreeBuilderAddedCallback C_TreeBuilderAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"added" FunPtr C_TreeBuilderAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [added](#signal:added) 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' treeBuilder #added 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.
-- 
afterTreeBuilderAdded :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderAddedCallback) -> m SignalHandlerId
afterTreeBuilderAdded :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a -> ((?self::a) => TreeBuilderAddedCallback) -> m SignalHandlerId
afterTreeBuilderAdded a
obj (?self::a) => TreeBuilderAddedCallback
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 -> TreeBuilderAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderAddedCallback
TreeBuilderAddedCallback
cb
    let wrapped' :: C_TreeBuilderAddedCallback
wrapped' = (a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
forall a.
GObject a =>
(a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
wrap_TreeBuilderAddedCallback a -> TreeBuilderAddedCallback
wrapped
    FunPtr C_TreeBuilderAddedCallback
wrapped'' <- C_TreeBuilderAddedCallback
-> IO (FunPtr C_TreeBuilderAddedCallback)
mk_TreeBuilderAddedCallback C_TreeBuilderAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"added" FunPtr C_TreeBuilderAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderAddedSignalInfo
instance SignalInfo TreeBuilderAddedSignalInfo where
    type HaskellCallbackType TreeBuilderAddedSignalInfo = TreeBuilderAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderAddedCallback cb
        cb'' <- mk_TreeBuilderAddedCallback cb'
        connectSignalFunPtr obj "added" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::added"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:added"})

#endif

-- signal TreeBuilder::build-children
-- | /No description available in the introspection data./
type TreeBuilderBuildChildrenCallback =
    Dazzle.TreeNode.TreeNode
    -> IO ()

type C_TreeBuilderBuildChildrenCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderBuildChildrenCallback :: 
    GObject a => (a -> TreeBuilderBuildChildrenCallback) ->
    C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildChildrenCallback :: forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildChildrenCallback a -> TreeBuilderBuildChildrenCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderBuildChildrenCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'


-- | Connect a signal handler for the [buildChildren](#signal:buildChildren) 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' treeBuilder #buildChildren callback
-- @
-- 
-- 
onTreeBuilderBuildChildren :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderBuildChildrenCallback) -> m SignalHandlerId
onTreeBuilderBuildChildren :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
onTreeBuilderBuildChildren a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildChildrenCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderBuildChildrenCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"build-children" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [buildChildren](#signal:buildChildren) 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' treeBuilder #buildChildren 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.
-- 
afterTreeBuilderBuildChildren :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderBuildChildrenCallback) -> m SignalHandlerId
afterTreeBuilderBuildChildren :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
afterTreeBuilderBuildChildren a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildChildrenCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderBuildChildrenCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"build-children" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderBuildChildrenSignalInfo
instance SignalInfo TreeBuilderBuildChildrenSignalInfo where
    type HaskellCallbackType TreeBuilderBuildChildrenSignalInfo = TreeBuilderBuildChildrenCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderBuildChildrenCallback cb
        cb'' <- mk_TreeBuilderBuildChildrenCallback cb'
        connectSignalFunPtr obj "build-children" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::build-children"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:buildChildren"})

#endif

-- signal TreeBuilder::build-node
-- | /No description available in the introspection data./
type TreeBuilderBuildNodeCallback =
    Dazzle.TreeNode.TreeNode
    -> IO ()

type C_TreeBuilderBuildNodeCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderBuildNodeCallback :: 
    GObject a => (a -> TreeBuilderBuildNodeCallback) ->
    C_TreeBuilderBuildNodeCallback
wrap_TreeBuilderBuildNodeCallback :: forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildNodeCallback a -> TreeBuilderBuildChildrenCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderBuildChildrenCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'


-- | Connect a signal handler for the [buildNode](#signal:buildNode) 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' treeBuilder #buildNode callback
-- @
-- 
-- 
onTreeBuilderBuildNode :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderBuildNodeCallback) -> m SignalHandlerId
onTreeBuilderBuildNode :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
onTreeBuilderBuildNode a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildNodeCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderBuildNodeCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"build-node" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [buildNode](#signal:buildNode) 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' treeBuilder #buildNode 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.
-- 
afterTreeBuilderBuildNode :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderBuildNodeCallback) -> m SignalHandlerId
afterTreeBuilderBuildNode :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
afterTreeBuilderBuildNode a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderBuildNodeCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderBuildNodeCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"build-node" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderBuildNodeSignalInfo
instance SignalInfo TreeBuilderBuildNodeSignalInfo where
    type HaskellCallbackType TreeBuilderBuildNodeSignalInfo = TreeBuilderBuildNodeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderBuildNodeCallback cb
        cb'' <- mk_TreeBuilderBuildNodeCallback cb'
        connectSignalFunPtr obj "build-node" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::build-node"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:buildNode"})

#endif

-- signal TreeBuilder::drag-data-get
-- | /No description available in the introspection data./
type TreeBuilderDragDataGetCallback =
    Dazzle.TreeNode.TreeNode
    -> Gtk.SelectionData.SelectionData
    -> IO Bool

type C_TreeBuilderDragDataGetCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr Gtk.SelectionData.SelectionData ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderDragDataGetCallback :: 
    GObject a => (a -> TreeBuilderDragDataGetCallback) ->
    C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderDragDataGetCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderDragDataGetCallback a -> TreeBuilderDragDataGetCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr SelectionData
p0 Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr SelectionData -> (SelectionData -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr SelectionData
p0 ((SelectionData -> IO CInt) -> IO CInt)
-> (SelectionData -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \SelectionData
p0' -> do
        Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragDataGetCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object' SelectionData
p0'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [dragDataGet](#signal:dragDataGet) 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' treeBuilder #dragDataGet callback
-- @
-- 
-- 
onTreeBuilderDragDataGet :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragDataGetCallback) -> m SignalHandlerId
onTreeBuilderDragDataGet :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragDataGetCallback)
-> m SignalHandlerId
onTreeBuilderDragDataGet a
obj (?self::a) => TreeBuilderDragDataGetCallback
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 -> TreeBuilderDragDataGetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragDataGetCallback
TreeBuilderDragDataGetCallback
cb
    let wrapped' :: C_TreeBuilderDragDataGetCallback
wrapped' = (a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
forall a.
GObject a =>
(a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderDragDataGetCallback a -> TreeBuilderDragDataGetCallback
wrapped
    FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' <- C_TreeBuilderDragDataGetCallback
-> IO (FunPtr C_TreeBuilderDragDataGetCallback)
mk_TreeBuilderDragDataGetCallback C_TreeBuilderDragDataGetCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragDataGetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-data-get" FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragDataGet](#signal:dragDataGet) 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' treeBuilder #dragDataGet 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.
-- 
afterTreeBuilderDragDataGet :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragDataGetCallback) -> m SignalHandlerId
afterTreeBuilderDragDataGet :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragDataGetCallback)
-> m SignalHandlerId
afterTreeBuilderDragDataGet a
obj (?self::a) => TreeBuilderDragDataGetCallback
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 -> TreeBuilderDragDataGetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragDataGetCallback
TreeBuilderDragDataGetCallback
cb
    let wrapped' :: C_TreeBuilderDragDataGetCallback
wrapped' = (a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
forall a.
GObject a =>
(a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderDragDataGetCallback a -> TreeBuilderDragDataGetCallback
wrapped
    FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' <- C_TreeBuilderDragDataGetCallback
-> IO (FunPtr C_TreeBuilderDragDataGetCallback)
mk_TreeBuilderDragDataGetCallback C_TreeBuilderDragDataGetCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragDataGetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-data-get" FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderDragDataGetSignalInfo
instance SignalInfo TreeBuilderDragDataGetSignalInfo where
    type HaskellCallbackType TreeBuilderDragDataGetSignalInfo = TreeBuilderDragDataGetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderDragDataGetCallback cb
        cb'' <- mk_TreeBuilderDragDataGetCallback cb'
        connectSignalFunPtr obj "drag-data-get" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::drag-data-get"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:dragDataGet"})

#endif

-- signal TreeBuilder::drag-data-received
-- | /No description available in the introspection data./
type TreeBuilderDragDataReceivedCallback =
    Dazzle.TreeNode.TreeNode
    -> Dazzle.Enums.TreeDropPosition
    -> [Gdk.Flags.DragAction]
    -> Gtk.SelectionData.SelectionData
    -> IO Bool

type C_TreeBuilderDragDataReceivedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    CUInt ->
    CUInt ->
    Ptr Gtk.SelectionData.SelectionData ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderDragDataReceivedCallback :: 
    GObject a => (a -> TreeBuilderDragDataReceivedCallback) ->
    C_TreeBuilderDragDataReceivedCallback
wrap_TreeBuilderDragDataReceivedCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragDataReceivedCallback)
-> C_TreeBuilderDragDataReceivedCallback
wrap_TreeBuilderDragDataReceivedCallback a -> TreeBuilderDragDataReceivedCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object CUInt
p0 CUInt
p1 Ptr SelectionData
p2 Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    let p0' :: TreeDropPosition
p0' = (Int -> TreeDropPosition
forall a. Enum a => Int -> a
toEnum (Int -> TreeDropPosition)
-> (CUInt -> Int) -> CUInt -> TreeDropPosition
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
p0
    let p1' :: [DragAction]
p1' = CUInt -> [DragAction]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
p1
    Ptr SelectionData -> (SelectionData -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr SelectionData
p2 ((SelectionData -> IO CInt) -> IO CInt)
-> (SelectionData -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \SelectionData
p2' -> do
        Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragDataReceivedCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object' TreeDropPosition
p0' [DragAction]
p1' SelectionData
p2'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [dragDataReceived](#signal:dragDataReceived) 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' treeBuilder #dragDataReceived callback
-- @
-- 
-- 
onTreeBuilderDragDataReceived :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragDataReceivedCallback) -> m SignalHandlerId
onTreeBuilderDragDataReceived :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragDataReceivedCallback)
-> m SignalHandlerId
onTreeBuilderDragDataReceived a
obj (?self::a) => TreeBuilderDragDataReceivedCallback
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 -> TreeBuilderDragDataReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragDataReceivedCallback
TreeBuilderDragDataReceivedCallback
cb
    let wrapped' :: C_TreeBuilderDragDataReceivedCallback
wrapped' = (a -> TreeBuilderDragDataReceivedCallback)
-> C_TreeBuilderDragDataReceivedCallback
forall a.
GObject a =>
(a -> TreeBuilderDragDataReceivedCallback)
-> C_TreeBuilderDragDataReceivedCallback
wrap_TreeBuilderDragDataReceivedCallback a -> TreeBuilderDragDataReceivedCallback
wrapped
    FunPtr C_TreeBuilderDragDataReceivedCallback
wrapped'' <- C_TreeBuilderDragDataReceivedCallback
-> IO (FunPtr C_TreeBuilderDragDataReceivedCallback)
mk_TreeBuilderDragDataReceivedCallback C_TreeBuilderDragDataReceivedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragDataReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-data-received" FunPtr C_TreeBuilderDragDataReceivedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragDataReceived](#signal:dragDataReceived) 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' treeBuilder #dragDataReceived 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.
-- 
afterTreeBuilderDragDataReceived :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragDataReceivedCallback) -> m SignalHandlerId
afterTreeBuilderDragDataReceived :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragDataReceivedCallback)
-> m SignalHandlerId
afterTreeBuilderDragDataReceived a
obj (?self::a) => TreeBuilderDragDataReceivedCallback
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 -> TreeBuilderDragDataReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragDataReceivedCallback
TreeBuilderDragDataReceivedCallback
cb
    let wrapped' :: C_TreeBuilderDragDataReceivedCallback
wrapped' = (a -> TreeBuilderDragDataReceivedCallback)
-> C_TreeBuilderDragDataReceivedCallback
forall a.
GObject a =>
(a -> TreeBuilderDragDataReceivedCallback)
-> C_TreeBuilderDragDataReceivedCallback
wrap_TreeBuilderDragDataReceivedCallback a -> TreeBuilderDragDataReceivedCallback
wrapped
    FunPtr C_TreeBuilderDragDataReceivedCallback
wrapped'' <- C_TreeBuilderDragDataReceivedCallback
-> IO (FunPtr C_TreeBuilderDragDataReceivedCallback)
mk_TreeBuilderDragDataReceivedCallback C_TreeBuilderDragDataReceivedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragDataReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-data-received" FunPtr C_TreeBuilderDragDataReceivedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderDragDataReceivedSignalInfo
instance SignalInfo TreeBuilderDragDataReceivedSignalInfo where
    type HaskellCallbackType TreeBuilderDragDataReceivedSignalInfo = TreeBuilderDragDataReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderDragDataReceivedCallback cb
        cb'' <- mk_TreeBuilderDragDataReceivedCallback cb'
        connectSignalFunPtr obj "drag-data-received" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::drag-data-received"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:dragDataReceived"})

#endif

-- signal TreeBuilder::drag-node-delete
-- | /No description available in the introspection data./
type TreeBuilderDragNodeDeleteCallback =
    Dazzle.TreeNode.TreeNode
    -> IO Bool

type C_TreeBuilderDragNodeDeleteCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderDragNodeDeleteCallback :: 
    GObject a => (a -> TreeBuilderDragNodeDeleteCallback) ->
    C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderDragNodeDeleteCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderDragNodeDeleteCallback a -> TreeBuilderDragNodeDeleteCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragNodeDeleteCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [dragNodeDelete](#signal:dragNodeDelete) 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' treeBuilder #dragNodeDelete callback
-- @
-- 
-- 
onTreeBuilderDragNodeDelete :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragNodeDeleteCallback) -> m SignalHandlerId
onTreeBuilderDragNodeDelete :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeDeleteCallback)
-> m SignalHandlerId
onTreeBuilderDragNodeDelete a
obj (?self::a) => TreeBuilderDragNodeDeleteCallback
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 -> TreeBuilderDragNodeDeleteCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeDeleteCallback
TreeBuilderDragNodeDeleteCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeDeleteCallback
wrapped' = (a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderDragNodeDeleteCallback a -> TreeBuilderDragNodeDeleteCallback
wrapped
    FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' <- C_TreeBuilderDragNodeDeleteCallback
-> IO (FunPtr C_TreeBuilderDragNodeDeleteCallback)
mk_TreeBuilderDragNodeDeleteCallback C_TreeBuilderDragNodeDeleteCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeDeleteCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-node-delete" FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragNodeDelete](#signal:dragNodeDelete) 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' treeBuilder #dragNodeDelete 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.
-- 
afterTreeBuilderDragNodeDelete :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragNodeDeleteCallback) -> m SignalHandlerId
afterTreeBuilderDragNodeDelete :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeDeleteCallback)
-> m SignalHandlerId
afterTreeBuilderDragNodeDelete a
obj (?self::a) => TreeBuilderDragNodeDeleteCallback
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 -> TreeBuilderDragNodeDeleteCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeDeleteCallback
TreeBuilderDragNodeDeleteCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeDeleteCallback
wrapped' = (a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderDragNodeDeleteCallback a -> TreeBuilderDragNodeDeleteCallback
wrapped
    FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' <- C_TreeBuilderDragNodeDeleteCallback
-> IO (FunPtr C_TreeBuilderDragNodeDeleteCallback)
mk_TreeBuilderDragNodeDeleteCallback C_TreeBuilderDragNodeDeleteCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeDeleteCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-node-delete" FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderDragNodeDeleteSignalInfo
instance SignalInfo TreeBuilderDragNodeDeleteSignalInfo where
    type HaskellCallbackType TreeBuilderDragNodeDeleteSignalInfo = TreeBuilderDragNodeDeleteCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderDragNodeDeleteCallback cb
        cb'' <- mk_TreeBuilderDragNodeDeleteCallback cb'
        connectSignalFunPtr obj "drag-node-delete" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::drag-node-delete"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:dragNodeDelete"})

#endif

-- signal TreeBuilder::drag-node-received
-- | /No description available in the introspection data./
type TreeBuilderDragNodeReceivedCallback =
    Dazzle.TreeNode.TreeNode
    -> Dazzle.TreeNode.TreeNode
    -> Dazzle.Enums.TreeDropPosition
    -> [Gdk.Flags.DragAction]
    -> Gtk.SelectionData.SelectionData
    -> IO Bool

type C_TreeBuilderDragNodeReceivedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr Dazzle.TreeNode.TreeNode ->
    CUInt ->
    CUInt ->
    Ptr Gtk.SelectionData.SelectionData ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderDragNodeReceivedCallback :: 
    GObject a => (a -> TreeBuilderDragNodeReceivedCallback) ->
    C_TreeBuilderDragNodeReceivedCallback
wrap_TreeBuilderDragNodeReceivedCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragNodeReceivedCallback)
-> C_TreeBuilderDragNodeReceivedCallback
wrap_TreeBuilderDragNodeReceivedCallback a -> TreeBuilderDragNodeReceivedCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr TreeNode
p0 CUInt
p1 CUInt
p2 Ptr SelectionData
p3 Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    TreeNode
p0' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
p0
    let p1' :: TreeDropPosition
p1' = (Int -> TreeDropPosition
forall a. Enum a => Int -> a
toEnum (Int -> TreeDropPosition)
-> (CUInt -> Int) -> CUInt -> TreeDropPosition
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
p1
    let p2' :: [DragAction]
p2' = CUInt -> [DragAction]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
p2
    Ptr SelectionData -> (SelectionData -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr SelectionData
p3 ((SelectionData -> IO CInt) -> IO CInt)
-> (SelectionData -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \SelectionData
p3' -> do
        Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragNodeReceivedCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object' TreeNode
p0' TreeDropPosition
p1' [DragAction]
p2' SelectionData
p3'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [dragNodeReceived](#signal:dragNodeReceived) 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' treeBuilder #dragNodeReceived callback
-- @
-- 
-- 
onTreeBuilderDragNodeReceived :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragNodeReceivedCallback) -> m SignalHandlerId
onTreeBuilderDragNodeReceived :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeReceivedCallback)
-> m SignalHandlerId
onTreeBuilderDragNodeReceived a
obj (?self::a) => TreeBuilderDragNodeReceivedCallback
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 -> TreeBuilderDragNodeReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeReceivedCallback
TreeBuilderDragNodeReceivedCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeReceivedCallback
wrapped' = (a -> TreeBuilderDragNodeReceivedCallback)
-> C_TreeBuilderDragNodeReceivedCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeReceivedCallback)
-> C_TreeBuilderDragNodeReceivedCallback
wrap_TreeBuilderDragNodeReceivedCallback a -> TreeBuilderDragNodeReceivedCallback
wrapped
    FunPtr C_TreeBuilderDragNodeReceivedCallback
wrapped'' <- C_TreeBuilderDragNodeReceivedCallback
-> IO (FunPtr C_TreeBuilderDragNodeReceivedCallback)
mk_TreeBuilderDragNodeReceivedCallback C_TreeBuilderDragNodeReceivedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-node-received" FunPtr C_TreeBuilderDragNodeReceivedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragNodeReceived](#signal:dragNodeReceived) 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' treeBuilder #dragNodeReceived 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.
-- 
afterTreeBuilderDragNodeReceived :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderDragNodeReceivedCallback) -> m SignalHandlerId
afterTreeBuilderDragNodeReceived :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeReceivedCallback)
-> m SignalHandlerId
afterTreeBuilderDragNodeReceived a
obj (?self::a) => TreeBuilderDragNodeReceivedCallback
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 -> TreeBuilderDragNodeReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeReceivedCallback
TreeBuilderDragNodeReceivedCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeReceivedCallback
wrapped' = (a -> TreeBuilderDragNodeReceivedCallback)
-> C_TreeBuilderDragNodeReceivedCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeReceivedCallback)
-> C_TreeBuilderDragNodeReceivedCallback
wrap_TreeBuilderDragNodeReceivedCallback a -> TreeBuilderDragNodeReceivedCallback
wrapped
    FunPtr C_TreeBuilderDragNodeReceivedCallback
wrapped'' <- C_TreeBuilderDragNodeReceivedCallback
-> IO (FunPtr C_TreeBuilderDragNodeReceivedCallback)
mk_TreeBuilderDragNodeReceivedCallback C_TreeBuilderDragNodeReceivedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-node-received" FunPtr C_TreeBuilderDragNodeReceivedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderDragNodeReceivedSignalInfo
instance SignalInfo TreeBuilderDragNodeReceivedSignalInfo where
    type HaskellCallbackType TreeBuilderDragNodeReceivedSignalInfo = TreeBuilderDragNodeReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderDragNodeReceivedCallback cb
        cb'' <- mk_TreeBuilderDragNodeReceivedCallback cb'
        connectSignalFunPtr obj "drag-node-received" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::drag-node-received"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:dragNodeReceived"})

#endif

-- signal TreeBuilder::node-activated
-- | /No description available in the introspection data./
type TreeBuilderNodeActivatedCallback =
    Dazzle.TreeNode.TreeNode
    -> IO Bool

type C_TreeBuilderNodeActivatedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderNodeActivatedCallback :: 
    GObject a => (a -> TreeBuilderNodeActivatedCallback) ->
    C_TreeBuilderNodeActivatedCallback
wrap_TreeBuilderNodeActivatedCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderNodeActivatedCallback a -> TreeBuilderDragNodeDeleteCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragNodeDeleteCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [nodeActivated](#signal:nodeActivated) 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' treeBuilder #nodeActivated callback
-- @
-- 
-- 
onTreeBuilderNodeActivated :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeActivatedCallback) -> m SignalHandlerId
onTreeBuilderNodeActivated :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeDeleteCallback)
-> m SignalHandlerId
onTreeBuilderNodeActivated a
obj (?self::a) => TreeBuilderDragNodeDeleteCallback
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 -> TreeBuilderDragNodeDeleteCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeDeleteCallback
TreeBuilderDragNodeDeleteCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeDeleteCallback
wrapped' = (a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderNodeActivatedCallback a -> TreeBuilderDragNodeDeleteCallback
wrapped
    FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' <- C_TreeBuilderDragNodeDeleteCallback
-> IO (FunPtr C_TreeBuilderDragNodeDeleteCallback)
mk_TreeBuilderNodeActivatedCallback C_TreeBuilderDragNodeDeleteCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeDeleteCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-activated" FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeActivated](#signal:nodeActivated) 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' treeBuilder #nodeActivated 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.
-- 
afterTreeBuilderNodeActivated :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeActivatedCallback) -> m SignalHandlerId
afterTreeBuilderNodeActivated :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeDeleteCallback)
-> m SignalHandlerId
afterTreeBuilderNodeActivated a
obj (?self::a) => TreeBuilderDragNodeDeleteCallback
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 -> TreeBuilderDragNodeDeleteCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeDeleteCallback
TreeBuilderDragNodeDeleteCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeDeleteCallback
wrapped' = (a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderNodeActivatedCallback a -> TreeBuilderDragNodeDeleteCallback
wrapped
    FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' <- C_TreeBuilderDragNodeDeleteCallback
-> IO (FunPtr C_TreeBuilderDragNodeDeleteCallback)
mk_TreeBuilderNodeActivatedCallback C_TreeBuilderDragNodeDeleteCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeDeleteCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-activated" FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeActivatedSignalInfo
instance SignalInfo TreeBuilderNodeActivatedSignalInfo where
    type HaskellCallbackType TreeBuilderNodeActivatedSignalInfo = TreeBuilderNodeActivatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeActivatedCallback cb
        cb'' <- mk_TreeBuilderNodeActivatedCallback cb'
        connectSignalFunPtr obj "node-activated" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeActivated"})

#endif

-- signal TreeBuilder::node-collapsed
-- | /No description available in the introspection data./
type TreeBuilderNodeCollapsedCallback =
    Dazzle.TreeNode.TreeNode
    -> IO ()

type C_TreeBuilderNodeCollapsedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderNodeCollapsedCallback :: 
    GObject a => (a -> TreeBuilderNodeCollapsedCallback) ->
    C_TreeBuilderNodeCollapsedCallback
wrap_TreeBuilderNodeCollapsedCallback :: forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeCollapsedCallback a -> TreeBuilderBuildChildrenCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderBuildChildrenCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'


-- | Connect a signal handler for the [nodeCollapsed](#signal:nodeCollapsed) 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' treeBuilder #nodeCollapsed callback
-- @
-- 
-- 
onTreeBuilderNodeCollapsed :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeCollapsedCallback) -> m SignalHandlerId
onTreeBuilderNodeCollapsed :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
onTreeBuilderNodeCollapsed a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeCollapsedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeCollapsedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-collapsed" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeCollapsed](#signal:nodeCollapsed) 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' treeBuilder #nodeCollapsed 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.
-- 
afterTreeBuilderNodeCollapsed :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeCollapsedCallback) -> m SignalHandlerId
afterTreeBuilderNodeCollapsed :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
afterTreeBuilderNodeCollapsed a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeCollapsedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeCollapsedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-collapsed" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeCollapsedSignalInfo
instance SignalInfo TreeBuilderNodeCollapsedSignalInfo where
    type HaskellCallbackType TreeBuilderNodeCollapsedSignalInfo = TreeBuilderNodeCollapsedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeCollapsedCallback cb
        cb'' <- mk_TreeBuilderNodeCollapsedCallback cb'
        connectSignalFunPtr obj "node-collapsed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-collapsed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeCollapsed"})

#endif

-- signal TreeBuilder::node-draggable
-- | /No description available in the introspection data./
type TreeBuilderNodeDraggableCallback =
    Dazzle.TreeNode.TreeNode
    -> IO Bool

type C_TreeBuilderNodeDraggableCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderNodeDraggableCallback :: 
    GObject a => (a -> TreeBuilderNodeDraggableCallback) ->
    C_TreeBuilderNodeDraggableCallback
wrap_TreeBuilderNodeDraggableCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderNodeDraggableCallback a -> TreeBuilderDragNodeDeleteCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragNodeDeleteCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [nodeDraggable](#signal:nodeDraggable) 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' treeBuilder #nodeDraggable callback
-- @
-- 
-- 
onTreeBuilderNodeDraggable :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeDraggableCallback) -> m SignalHandlerId
onTreeBuilderNodeDraggable :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeDeleteCallback)
-> m SignalHandlerId
onTreeBuilderNodeDraggable a
obj (?self::a) => TreeBuilderDragNodeDeleteCallback
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 -> TreeBuilderDragNodeDeleteCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeDeleteCallback
TreeBuilderDragNodeDeleteCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeDeleteCallback
wrapped' = (a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderNodeDraggableCallback a -> TreeBuilderDragNodeDeleteCallback
wrapped
    FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' <- C_TreeBuilderDragNodeDeleteCallback
-> IO (FunPtr C_TreeBuilderDragNodeDeleteCallback)
mk_TreeBuilderNodeDraggableCallback C_TreeBuilderDragNodeDeleteCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeDeleteCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-draggable" FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeDraggable](#signal:nodeDraggable) 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' treeBuilder #nodeDraggable 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.
-- 
afterTreeBuilderNodeDraggable :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeDraggableCallback) -> m SignalHandlerId
afterTreeBuilderNodeDraggable :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragNodeDeleteCallback)
-> m SignalHandlerId
afterTreeBuilderNodeDraggable a
obj (?self::a) => TreeBuilderDragNodeDeleteCallback
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 -> TreeBuilderDragNodeDeleteCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragNodeDeleteCallback
TreeBuilderDragNodeDeleteCallback
cb
    let wrapped' :: C_TreeBuilderDragNodeDeleteCallback
wrapped' = (a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
forall a.
GObject a =>
(a -> TreeBuilderDragNodeDeleteCallback)
-> C_TreeBuilderDragNodeDeleteCallback
wrap_TreeBuilderNodeDraggableCallback a -> TreeBuilderDragNodeDeleteCallback
wrapped
    FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' <- C_TreeBuilderDragNodeDeleteCallback
-> IO (FunPtr C_TreeBuilderDragNodeDeleteCallback)
mk_TreeBuilderNodeDraggableCallback C_TreeBuilderDragNodeDeleteCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragNodeDeleteCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-draggable" FunPtr C_TreeBuilderDragNodeDeleteCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeDraggableSignalInfo
instance SignalInfo TreeBuilderNodeDraggableSignalInfo where
    type HaskellCallbackType TreeBuilderNodeDraggableSignalInfo = TreeBuilderNodeDraggableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeDraggableCallback cb
        cb'' <- mk_TreeBuilderNodeDraggableCallback cb'
        connectSignalFunPtr obj "node-draggable" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-draggable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeDraggable"})

#endif

-- signal TreeBuilder::node-droppable
-- | /No description available in the introspection data./
type TreeBuilderNodeDroppableCallback =
    Dazzle.TreeNode.TreeNode
    -> Gtk.SelectionData.SelectionData
    -> IO Bool

type C_TreeBuilderNodeDroppableCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr Gtk.SelectionData.SelectionData ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TreeBuilderNodeDroppableCallback :: 
    GObject a => (a -> TreeBuilderNodeDroppableCallback) ->
    C_TreeBuilderNodeDroppableCallback
wrap_TreeBuilderNodeDroppableCallback :: forall a.
GObject a =>
(a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderNodeDroppableCallback a -> TreeBuilderDragDataGetCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr SelectionData
p0 Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr SelectionData -> (SelectionData -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr SelectionData
p0 ((SelectionData -> IO CInt) -> IO CInt)
-> (SelectionData -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \SelectionData
p0' -> do
        Bool
result <- Ptr TreeBuilder -> (TreeBuilder -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO Bool) -> IO Bool)
-> (TreeBuilder -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderDragDataGetCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object' SelectionData
p0'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [nodeDroppable](#signal:nodeDroppable) 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' treeBuilder #nodeDroppable callback
-- @
-- 
-- 
onTreeBuilderNodeDroppable :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeDroppableCallback) -> m SignalHandlerId
onTreeBuilderNodeDroppable :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragDataGetCallback)
-> m SignalHandlerId
onTreeBuilderNodeDroppable a
obj (?self::a) => TreeBuilderDragDataGetCallback
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 -> TreeBuilderDragDataGetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragDataGetCallback
TreeBuilderDragDataGetCallback
cb
    let wrapped' :: C_TreeBuilderDragDataGetCallback
wrapped' = (a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
forall a.
GObject a =>
(a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderNodeDroppableCallback a -> TreeBuilderDragDataGetCallback
wrapped
    FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' <- C_TreeBuilderDragDataGetCallback
-> IO (FunPtr C_TreeBuilderDragDataGetCallback)
mk_TreeBuilderNodeDroppableCallback C_TreeBuilderDragDataGetCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragDataGetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-droppable" FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeDroppable](#signal:nodeDroppable) 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' treeBuilder #nodeDroppable 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.
-- 
afterTreeBuilderNodeDroppable :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeDroppableCallback) -> m SignalHandlerId
afterTreeBuilderNodeDroppable :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderDragDataGetCallback)
-> m SignalHandlerId
afterTreeBuilderNodeDroppable a
obj (?self::a) => TreeBuilderDragDataGetCallback
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 -> TreeBuilderDragDataGetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderDragDataGetCallback
TreeBuilderDragDataGetCallback
cb
    let wrapped' :: C_TreeBuilderDragDataGetCallback
wrapped' = (a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
forall a.
GObject a =>
(a -> TreeBuilderDragDataGetCallback)
-> C_TreeBuilderDragDataGetCallback
wrap_TreeBuilderNodeDroppableCallback a -> TreeBuilderDragDataGetCallback
wrapped
    FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' <- C_TreeBuilderDragDataGetCallback
-> IO (FunPtr C_TreeBuilderDragDataGetCallback)
mk_TreeBuilderNodeDroppableCallback C_TreeBuilderDragDataGetCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderDragDataGetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-droppable" FunPtr C_TreeBuilderDragDataGetCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeDroppableSignalInfo
instance SignalInfo TreeBuilderNodeDroppableSignalInfo where
    type HaskellCallbackType TreeBuilderNodeDroppableSignalInfo = TreeBuilderNodeDroppableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeDroppableCallback cb
        cb'' <- mk_TreeBuilderNodeDroppableCallback cb'
        connectSignalFunPtr obj "node-droppable" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-droppable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeDroppable"})

#endif

-- signal TreeBuilder::node-expanded
-- | /No description available in the introspection data./
type TreeBuilderNodeExpandedCallback =
    Dazzle.TreeNode.TreeNode
    -> IO ()

type C_TreeBuilderNodeExpandedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderNodeExpandedCallback :: 
    GObject a => (a -> TreeBuilderNodeExpandedCallback) ->
    C_TreeBuilderNodeExpandedCallback
wrap_TreeBuilderNodeExpandedCallback :: forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeExpandedCallback a -> TreeBuilderBuildChildrenCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderBuildChildrenCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'


-- | Connect a signal handler for the [nodeExpanded](#signal:nodeExpanded) 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' treeBuilder #nodeExpanded callback
-- @
-- 
-- 
onTreeBuilderNodeExpanded :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeExpandedCallback) -> m SignalHandlerId
onTreeBuilderNodeExpanded :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
onTreeBuilderNodeExpanded a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeExpandedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeExpandedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-expanded" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeExpanded](#signal:nodeExpanded) 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' treeBuilder #nodeExpanded 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.
-- 
afterTreeBuilderNodeExpanded :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeExpandedCallback) -> m SignalHandlerId
afterTreeBuilderNodeExpanded :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
afterTreeBuilderNodeExpanded a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeExpandedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeExpandedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-expanded" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeExpandedSignalInfo
instance SignalInfo TreeBuilderNodeExpandedSignalInfo where
    type HaskellCallbackType TreeBuilderNodeExpandedSignalInfo = TreeBuilderNodeExpandedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeExpandedCallback cb
        cb'' <- mk_TreeBuilderNodeExpandedCallback cb'
        connectSignalFunPtr obj "node-expanded" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-expanded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeExpanded"})

#endif

-- signal TreeBuilder::node-popup
-- | /No description available in the introspection data./
type TreeBuilderNodePopupCallback =
    Dazzle.TreeNode.TreeNode
    -> Gio.Menu.Menu
    -> IO ()

type C_TreeBuilderNodePopupCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr Gio.Menu.Menu ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderNodePopupCallback :: 
    GObject a => (a -> TreeBuilderNodePopupCallback) ->
    C_TreeBuilderNodePopupCallback
wrap_TreeBuilderNodePopupCallback :: forall a.
GObject a =>
(a -> TreeBuilderNodePopupCallback)
-> C_TreeBuilderNodePopupCallback
wrap_TreeBuilderNodePopupCallback a -> TreeBuilderNodePopupCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr Menu
p0 Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Menu
p0' <- ((ManagedPtr Menu -> Menu) -> Ptr Menu -> IO Menu
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menu -> Menu
Gio.Menu.Menu) Ptr Menu
p0
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderNodePopupCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object' Menu
p0'


-- | Connect a signal handler for the [nodePopup](#signal:nodePopup) 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' treeBuilder #nodePopup callback
-- @
-- 
-- 
onTreeBuilderNodePopup :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodePopupCallback) -> m SignalHandlerId
onTreeBuilderNodePopup :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderNodePopupCallback)
-> m SignalHandlerId
onTreeBuilderNodePopup a
obj (?self::a) => TreeBuilderNodePopupCallback
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 -> TreeBuilderNodePopupCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderNodePopupCallback
TreeBuilderNodePopupCallback
cb
    let wrapped' :: C_TreeBuilderNodePopupCallback
wrapped' = (a -> TreeBuilderNodePopupCallback)
-> C_TreeBuilderNodePopupCallback
forall a.
GObject a =>
(a -> TreeBuilderNodePopupCallback)
-> C_TreeBuilderNodePopupCallback
wrap_TreeBuilderNodePopupCallback a -> TreeBuilderNodePopupCallback
wrapped
    FunPtr C_TreeBuilderNodePopupCallback
wrapped'' <- C_TreeBuilderNodePopupCallback
-> IO (FunPtr C_TreeBuilderNodePopupCallback)
mk_TreeBuilderNodePopupCallback C_TreeBuilderNodePopupCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderNodePopupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-popup" FunPtr C_TreeBuilderNodePopupCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodePopup](#signal:nodePopup) 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' treeBuilder #nodePopup 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.
-- 
afterTreeBuilderNodePopup :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodePopupCallback) -> m SignalHandlerId
afterTreeBuilderNodePopup :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderNodePopupCallback)
-> m SignalHandlerId
afterTreeBuilderNodePopup a
obj (?self::a) => TreeBuilderNodePopupCallback
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 -> TreeBuilderNodePopupCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderNodePopupCallback
TreeBuilderNodePopupCallback
cb
    let wrapped' :: C_TreeBuilderNodePopupCallback
wrapped' = (a -> TreeBuilderNodePopupCallback)
-> C_TreeBuilderNodePopupCallback
forall a.
GObject a =>
(a -> TreeBuilderNodePopupCallback)
-> C_TreeBuilderNodePopupCallback
wrap_TreeBuilderNodePopupCallback a -> TreeBuilderNodePopupCallback
wrapped
    FunPtr C_TreeBuilderNodePopupCallback
wrapped'' <- C_TreeBuilderNodePopupCallback
-> IO (FunPtr C_TreeBuilderNodePopupCallback)
mk_TreeBuilderNodePopupCallback C_TreeBuilderNodePopupCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderNodePopupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-popup" FunPtr C_TreeBuilderNodePopupCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodePopupSignalInfo
instance SignalInfo TreeBuilderNodePopupSignalInfo where
    type HaskellCallbackType TreeBuilderNodePopupSignalInfo = TreeBuilderNodePopupCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodePopupCallback cb
        cb'' <- mk_TreeBuilderNodePopupCallback cb'
        connectSignalFunPtr obj "node-popup" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-popup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodePopup"})

#endif

-- signal TreeBuilder::node-selected
-- | /No description available in the introspection data./
type TreeBuilderNodeSelectedCallback =
    Dazzle.TreeNode.TreeNode
    -> IO ()

type C_TreeBuilderNodeSelectedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderNodeSelectedCallback :: 
    GObject a => (a -> TreeBuilderNodeSelectedCallback) ->
    C_TreeBuilderNodeSelectedCallback
wrap_TreeBuilderNodeSelectedCallback :: forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeSelectedCallback a -> TreeBuilderBuildChildrenCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderBuildChildrenCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'


-- | Connect a signal handler for the [nodeSelected](#signal:nodeSelected) 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' treeBuilder #nodeSelected callback
-- @
-- 
-- 
onTreeBuilderNodeSelected :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeSelectedCallback) -> m SignalHandlerId
onTreeBuilderNodeSelected :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
onTreeBuilderNodeSelected a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeSelectedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeSelectedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-selected" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeSelected](#signal:nodeSelected) 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' treeBuilder #nodeSelected 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.
-- 
afterTreeBuilderNodeSelected :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeSelectedCallback) -> m SignalHandlerId
afterTreeBuilderNodeSelected :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
afterTreeBuilderNodeSelected a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeSelectedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeSelectedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-selected" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeSelectedSignalInfo
instance SignalInfo TreeBuilderNodeSelectedSignalInfo where
    type HaskellCallbackType TreeBuilderNodeSelectedSignalInfo = TreeBuilderNodeSelectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeSelectedCallback cb
        cb'' <- mk_TreeBuilderNodeSelectedCallback cb'
        connectSignalFunPtr obj "node-selected" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-selected"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeSelected"})

#endif

-- signal TreeBuilder::node-unselected
-- | /No description available in the introspection data./
type TreeBuilderNodeUnselectedCallback =
    Dazzle.TreeNode.TreeNode
    -> IO ()

type C_TreeBuilderNodeUnselectedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.TreeNode.TreeNode ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderNodeUnselectedCallback :: 
    GObject a => (a -> TreeBuilderNodeUnselectedCallback) ->
    C_TreeBuilderNodeUnselectedCallback
wrap_TreeBuilderNodeUnselectedCallback :: forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeUnselectedCallback a -> TreeBuilderBuildChildrenCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr TreeNode
object Ptr ()
_ = do
    TreeNode
object' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderBuildChildrenCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  TreeNode
object'


-- | Connect a signal handler for the [nodeUnselected](#signal:nodeUnselected) 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' treeBuilder #nodeUnselected callback
-- @
-- 
-- 
onTreeBuilderNodeUnselected :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeUnselectedCallback) -> m SignalHandlerId
onTreeBuilderNodeUnselected :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
onTreeBuilderNodeUnselected a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeUnselectedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeUnselectedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-unselected" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nodeUnselected](#signal:nodeUnselected) 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' treeBuilder #nodeUnselected 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.
-- 
afterTreeBuilderNodeUnselected :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderNodeUnselectedCallback) -> m SignalHandlerId
afterTreeBuilderNodeUnselected :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a
-> ((?self::a) => TreeBuilderBuildChildrenCallback)
-> m SignalHandlerId
afterTreeBuilderNodeUnselected a
obj (?self::a) => TreeBuilderBuildChildrenCallback
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 -> TreeBuilderBuildChildrenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderBuildChildrenCallback
TreeBuilderBuildChildrenCallback
cb
    let wrapped' :: C_TreeBuilderBuildChildrenCallback
wrapped' = (a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
forall a.
GObject a =>
(a -> TreeBuilderBuildChildrenCallback)
-> C_TreeBuilderBuildChildrenCallback
wrap_TreeBuilderNodeUnselectedCallback a -> TreeBuilderBuildChildrenCallback
wrapped
    FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' <- C_TreeBuilderBuildChildrenCallback
-> IO (FunPtr C_TreeBuilderBuildChildrenCallback)
mk_TreeBuilderNodeUnselectedCallback C_TreeBuilderBuildChildrenCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderBuildChildrenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"node-unselected" FunPtr C_TreeBuilderBuildChildrenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderNodeUnselectedSignalInfo
instance SignalInfo TreeBuilderNodeUnselectedSignalInfo where
    type HaskellCallbackType TreeBuilderNodeUnselectedSignalInfo = TreeBuilderNodeUnselectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderNodeUnselectedCallback cb
        cb'' <- mk_TreeBuilderNodeUnselectedCallback cb'
        connectSignalFunPtr obj "node-unselected" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::node-unselected"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:nodeUnselected"})

#endif

-- signal TreeBuilder::removed
-- | /No description available in the introspection data./
type TreeBuilderRemovedCallback =
    Dazzle.Tree.Tree
    -> IO ()

type C_TreeBuilderRemovedCallback =
    Ptr TreeBuilder ->                      -- object
    Ptr Dazzle.Tree.Tree ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeBuilderRemovedCallback :: 
    GObject a => (a -> TreeBuilderRemovedCallback) ->
    C_TreeBuilderRemovedCallback
wrap_TreeBuilderRemovedCallback :: forall a.
GObject a =>
(a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
wrap_TreeBuilderRemovedCallback a -> TreeBuilderAddedCallback
gi'cb Ptr TreeBuilder
gi'selfPtr Ptr Tree
object Ptr ()
_ = do
    Tree
object' <- ((ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Tree -> Tree
Dazzle.Tree.Tree) Ptr Tree
object
    Ptr TreeBuilder -> (TreeBuilder -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr TreeBuilder
gi'selfPtr ((TreeBuilder -> IO ()) -> IO ())
-> (TreeBuilder -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TreeBuilder
gi'self -> a -> TreeBuilderAddedCallback
gi'cb (TreeBuilder -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TreeBuilder
gi'self)  Tree
object'


-- | Connect a signal handler for the [removed](#signal:removed) 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' treeBuilder #removed callback
-- @
-- 
-- 
onTreeBuilderRemoved :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderRemovedCallback) -> m SignalHandlerId
onTreeBuilderRemoved :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a -> ((?self::a) => TreeBuilderAddedCallback) -> m SignalHandlerId
onTreeBuilderRemoved a
obj (?self::a) => TreeBuilderAddedCallback
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 -> TreeBuilderAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderAddedCallback
TreeBuilderAddedCallback
cb
    let wrapped' :: C_TreeBuilderAddedCallback
wrapped' = (a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
forall a.
GObject a =>
(a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
wrap_TreeBuilderRemovedCallback a -> TreeBuilderAddedCallback
wrapped
    FunPtr C_TreeBuilderAddedCallback
wrapped'' <- C_TreeBuilderAddedCallback
-> IO (FunPtr C_TreeBuilderAddedCallback)
mk_TreeBuilderRemovedCallback C_TreeBuilderAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"removed" FunPtr C_TreeBuilderAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [removed](#signal:removed) 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' treeBuilder #removed 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.
-- 
afterTreeBuilderRemoved :: (IsTreeBuilder a, MonadIO m) => a -> ((?self :: a) => TreeBuilderRemovedCallback) -> m SignalHandlerId
afterTreeBuilderRemoved :: forall a (m :: * -> *).
(IsTreeBuilder a, MonadIO m) =>
a -> ((?self::a) => TreeBuilderAddedCallback) -> m SignalHandlerId
afterTreeBuilderRemoved a
obj (?self::a) => TreeBuilderAddedCallback
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 -> TreeBuilderAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TreeBuilderAddedCallback
TreeBuilderAddedCallback
cb
    let wrapped' :: C_TreeBuilderAddedCallback
wrapped' = (a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
forall a.
GObject a =>
(a -> TreeBuilderAddedCallback) -> C_TreeBuilderAddedCallback
wrap_TreeBuilderRemovedCallback a -> TreeBuilderAddedCallback
wrapped
    FunPtr C_TreeBuilderAddedCallback
wrapped'' <- C_TreeBuilderAddedCallback
-> IO (FunPtr C_TreeBuilderAddedCallback)
mk_TreeBuilderRemovedCallback C_TreeBuilderAddedCallback
wrapped'
    a
-> Text
-> FunPtr C_TreeBuilderAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"removed" FunPtr C_TreeBuilderAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TreeBuilderRemovedSignalInfo
instance SignalInfo TreeBuilderRemovedSignalInfo where
    type HaskellCallbackType TreeBuilderRemovedSignalInfo = TreeBuilderRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeBuilderRemovedCallback cb
        cb'' <- mk_TreeBuilderRemovedCallback cb'
        connectSignalFunPtr obj "removed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder::removed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:signal:removed"})

#endif

-- VVV Prop "tree"
   -- Type: TInterface (Name {namespace = "Dazzle", name = "Tree"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@tree@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' treeBuilder #tree
-- @
getTreeBuilderTree :: (MonadIO m, IsTreeBuilder o) => o -> m (Maybe Dazzle.Tree.Tree)
getTreeBuilderTree :: forall (m :: * -> *) o.
(MonadIO m, IsTreeBuilder o) =>
o -> m (Maybe Tree)
getTreeBuilderTree o
obj = IO (Maybe Tree) -> m (Maybe Tree)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Tree) -> m (Maybe Tree))
-> IO (Maybe Tree) -> m (Maybe Tree)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Tree -> Tree) -> IO (Maybe Tree)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"tree" ManagedPtr Tree -> Tree
Dazzle.Tree.Tree

#if defined(ENABLE_OVERLOADING)
data TreeBuilderTreePropertyInfo
instance AttrInfo TreeBuilderTreePropertyInfo where
    type AttrAllowedOps TreeBuilderTreePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TreeBuilderTreePropertyInfo = IsTreeBuilder
    type AttrSetTypeConstraint TreeBuilderTreePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TreeBuilderTreePropertyInfo = (~) ()
    type AttrTransferType TreeBuilderTreePropertyInfo = ()
    type AttrGetType TreeBuilderTreePropertyInfo = (Maybe Dazzle.Tree.Tree)
    type AttrLabel TreeBuilderTreePropertyInfo = "tree"
    type AttrOrigin TreeBuilderTreePropertyInfo = TreeBuilder
    attrGet = getTreeBuilderTree
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder.tree"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#g:attr:tree"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeBuilder
type instance O.AttributeList TreeBuilder = TreeBuilderAttributeList
type TreeBuilderAttributeList = ('[ '("tree", TreeBuilderTreePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
treeBuilderTree :: AttrLabelProxy "tree"
treeBuilderTree = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TreeBuilder = TreeBuilderSignalList
type TreeBuilderSignalList = ('[ '("added", TreeBuilderAddedSignalInfo), '("buildChildren", TreeBuilderBuildChildrenSignalInfo), '("buildNode", TreeBuilderBuildNodeSignalInfo), '("dragDataGet", TreeBuilderDragDataGetSignalInfo), '("dragDataReceived", TreeBuilderDragDataReceivedSignalInfo), '("dragNodeDelete", TreeBuilderDragNodeDeleteSignalInfo), '("dragNodeReceived", TreeBuilderDragNodeReceivedSignalInfo), '("nodeActivated", TreeBuilderNodeActivatedSignalInfo), '("nodeCollapsed", TreeBuilderNodeCollapsedSignalInfo), '("nodeDraggable", TreeBuilderNodeDraggableSignalInfo), '("nodeDroppable", TreeBuilderNodeDroppableSignalInfo), '("nodeExpanded", TreeBuilderNodeExpandedSignalInfo), '("nodePopup", TreeBuilderNodePopupSignalInfo), '("nodeSelected", TreeBuilderNodeSelectedSignalInfo), '("nodeUnselected", TreeBuilderNodeUnselectedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("removed", TreeBuilderRemovedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "dzl_tree_builder_new" dzl_tree_builder_new :: 
    IO (Ptr TreeBuilder)

-- | /No description available in the introspection data./
treeBuilderNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TreeBuilder
treeBuilderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TreeBuilder
treeBuilderNew  = IO TreeBuilder -> m TreeBuilder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeBuilder -> m TreeBuilder)
-> IO TreeBuilder -> m TreeBuilder
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
result <- IO (Ptr TreeBuilder)
dzl_tree_builder_new
    Text -> Ptr TreeBuilder -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeBuilderNew" Ptr TreeBuilder
result
    TreeBuilder
result' <- ((ManagedPtr TreeBuilder -> TreeBuilder)
-> Ptr TreeBuilder -> IO TreeBuilder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeBuilder -> TreeBuilder
TreeBuilder) Ptr TreeBuilder
result
    TreeBuilder -> IO TreeBuilder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeBuilder
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method TreeBuilder::get_tree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "TreeBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlTreeBuilder." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Dazzle" , name = "Tree" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_tree_builder_get_tree" dzl_tree_builder_get_tree :: 
    Ptr TreeBuilder ->                      -- builder : TInterface (Name {namespace = "Dazzle", name = "TreeBuilder"})
    IO (Ptr Dazzle.Tree.Tree)

-- | Gets the tree that owns the builder.
treeBuilderGetTree ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
    a
    -- ^ /@builder@/: A t'GI.Dazzle.Objects.TreeBuilder.TreeBuilder'.
    -> m (Maybe Dazzle.Tree.Tree)
    -- ^ __Returns:__ A t'GI.Dazzle.Objects.Tree.Tree' or 'P.Nothing'.
treeBuilderGetTree :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeBuilder a) =>
a -> m (Maybe Tree)
treeBuilderGetTree a
builder = IO (Maybe Tree) -> m (Maybe Tree)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Tree) -> m (Maybe Tree))
-> IO (Maybe Tree) -> m (Maybe Tree)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Tree
result <- Ptr TreeBuilder -> IO (Ptr Tree)
dzl_tree_builder_get_tree Ptr TreeBuilder
builder'
    Maybe Tree
maybeResult <- Ptr Tree -> (Ptr Tree -> IO Tree) -> IO (Maybe Tree)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Tree
result ((Ptr Tree -> IO Tree) -> IO (Maybe Tree))
-> (Ptr Tree -> IO Tree) -> IO (Maybe Tree)
forall a b. (a -> b) -> a -> b
$ \Ptr Tree
result' -> do
        Tree
result'' <- ((ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Tree -> Tree
Dazzle.Tree.Tree) Ptr Tree
result'
        Tree -> IO Tree
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Tree
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Tree -> IO (Maybe Tree)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Tree
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeBuilderGetTreeMethodInfo
instance (signature ~ (m (Maybe Dazzle.Tree.Tree)), MonadIO m, IsTreeBuilder a) => O.OverloadedMethod TreeBuilderGetTreeMethodInfo a signature where
    overloadedMethod = treeBuilderGetTree

instance O.OverloadedMethodInfo TreeBuilderGetTreeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.TreeBuilder.treeBuilderGetTree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-TreeBuilder.html#v:treeBuilderGetTree"
        })


#endif