{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a git remote callbacks.

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

module GI.Ggit.Objects.RemoteCallbacks
    ( 

-- * Exported types
    RemoteCallbacks(..)                     ,
    IsRemoteCallbacks                       ,
    toRemoteCallbacks                       ,
    noRemoteCallbacks                       ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveRemoteCallbacksMethod            ,
#endif




 -- * Signals
-- ** completion #signal:completion#

    C_RemoteCallbacksCompletionCallback     ,
    RemoteCallbacksCompletionCallback       ,
#if defined(ENABLE_OVERLOADING)
    RemoteCallbacksCompletionSignalInfo     ,
#endif
    afterRemoteCallbacksCompletion          ,
    genClosure_RemoteCallbacksCompletion    ,
    mk_RemoteCallbacksCompletionCallback    ,
    noRemoteCallbacksCompletionCallback     ,
    onRemoteCallbacksCompletion             ,
    wrap_RemoteCallbacksCompletionCallback  ,


-- ** progress #signal:progress#

    C_RemoteCallbacksProgressCallback       ,
    RemoteCallbacksProgressCallback         ,
#if defined(ENABLE_OVERLOADING)
    RemoteCallbacksProgressSignalInfo       ,
#endif
    afterRemoteCallbacksProgress            ,
    genClosure_RemoteCallbacksProgress      ,
    mk_RemoteCallbacksProgressCallback      ,
    noRemoteCallbacksProgressCallback       ,
    onRemoteCallbacksProgress               ,
    wrap_RemoteCallbacksProgressCallback    ,


-- ** transferProgress #signal:transferProgress#

    C_RemoteCallbacksTransferProgressCallback,
    RemoteCallbacksTransferProgressCallback ,
#if defined(ENABLE_OVERLOADING)
    RemoteCallbacksTransferProgressSignalInfo,
#endif
    afterRemoteCallbacksTransferProgress    ,
    genClosure_RemoteCallbacksTransferProgress,
    mk_RemoteCallbacksTransferProgressCallback,
    noRemoteCallbacksTransferProgressCallback,
    onRemoteCallbacksTransferProgress       ,
    wrap_RemoteCallbacksTransferProgressCallback,


-- ** updateTips #signal:updateTips#

    C_RemoteCallbacksUpdateTipsCallback     ,
    RemoteCallbacksUpdateTipsCallback       ,
#if defined(ENABLE_OVERLOADING)
    RemoteCallbacksUpdateTipsSignalInfo     ,
#endif
    afterRemoteCallbacksUpdateTips          ,
    genClosure_RemoteCallbacksUpdateTips    ,
    mk_RemoteCallbacksUpdateTipsCallback    ,
    noRemoteCallbacksUpdateTipsCallback     ,
    onRemoteCallbacksUpdateTips             ,
    wrap_RemoteCallbacksUpdateTipsCallback  ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.TransferProgress as Ggit.TransferProgress

-- | Memory-managed wrapper type.
newtype RemoteCallbacks = RemoteCallbacks (ManagedPtr RemoteCallbacks)
    deriving (RemoteCallbacks -> RemoteCallbacks -> Bool
(RemoteCallbacks -> RemoteCallbacks -> Bool)
-> (RemoteCallbacks -> RemoteCallbacks -> Bool)
-> Eq RemoteCallbacks
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteCallbacks -> RemoteCallbacks -> Bool
$c/= :: RemoteCallbacks -> RemoteCallbacks -> Bool
== :: RemoteCallbacks -> RemoteCallbacks -> Bool
$c== :: RemoteCallbacks -> RemoteCallbacks -> Bool
Eq)
foreign import ccall "ggit_remote_callbacks_get_type"
    c_ggit_remote_callbacks_get_type :: IO GType

instance GObject RemoteCallbacks where
    gobjectType :: IO GType
gobjectType = IO GType
c_ggit_remote_callbacks_get_type
    

-- | Convert 'RemoteCallbacks' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue RemoteCallbacks where
    toGValue :: RemoteCallbacks -> IO GValue
toGValue o :: RemoteCallbacks
o = do
        GType
gtype <- IO GType
c_ggit_remote_callbacks_get_type
        RemoteCallbacks -> (Ptr RemoteCallbacks -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RemoteCallbacks
o (GType
-> (GValue -> Ptr RemoteCallbacks -> IO ())
-> Ptr RemoteCallbacks
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr RemoteCallbacks -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO RemoteCallbacks
fromGValue gv :: GValue
gv = do
        Ptr RemoteCallbacks
ptr <- GValue -> IO (Ptr RemoteCallbacks)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr RemoteCallbacks)
        (ManagedPtr RemoteCallbacks -> RemoteCallbacks)
-> Ptr RemoteCallbacks -> IO RemoteCallbacks
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr RemoteCallbacks -> RemoteCallbacks
RemoteCallbacks Ptr RemoteCallbacks
ptr
        
    

-- | Type class for types which can be safely cast to `RemoteCallbacks`, for instance with `toRemoteCallbacks`.
class (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o
instance (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o

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

-- | Cast to `RemoteCallbacks`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toRemoteCallbacks :: (MonadIO m, IsRemoteCallbacks o) => o -> m RemoteCallbacks
toRemoteCallbacks :: o -> m RemoteCallbacks
toRemoteCallbacks = IO RemoteCallbacks -> m RemoteCallbacks
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RemoteCallbacks -> m RemoteCallbacks)
-> (o -> IO RemoteCallbacks) -> o -> m RemoteCallbacks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr RemoteCallbacks -> RemoteCallbacks)
-> o -> IO RemoteCallbacks
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr RemoteCallbacks -> RemoteCallbacks
RemoteCallbacks

-- | A convenience alias for `Nothing` :: `Maybe` `RemoteCallbacks`.
noRemoteCallbacks :: Maybe RemoteCallbacks
noRemoteCallbacks :: Maybe RemoteCallbacks
noRemoteCallbacks = Maybe RemoteCallbacks
forall a. Maybe a
Nothing

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

instance (info ~ ResolveRemoteCallbacksMethod t RemoteCallbacks, O.MethodInfo info RemoteCallbacks p) => OL.IsLabel t (RemoteCallbacks -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- signal RemoteCallbacks::completion
-- | /No description available in the introspection data./
type RemoteCallbacksCompletionCallback =
    Ggit.Enums.RemoteCompletionType
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksCompletionCallback`@.
noRemoteCallbacksCompletionCallback :: Maybe RemoteCallbacksCompletionCallback
noRemoteCallbacksCompletionCallback :: Maybe RemoteCallbacksCompletionCallback
noRemoteCallbacksCompletionCallback = Maybe RemoteCallbacksCompletionCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksCompletionCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksCompletion :: MonadIO m => RemoteCallbacksCompletionCallback -> m (GClosure C_RemoteCallbacksCompletionCallback)
genClosure_RemoteCallbacksCompletion :: RemoteCallbacksCompletionCallback
-> m (GClosure C_RemoteCallbacksCompletionCallback)
genClosure_RemoteCallbacksCompletion cb :: RemoteCallbacksCompletionCallback
cb = IO (GClosure C_RemoteCallbacksCompletionCallback)
-> m (GClosure C_RemoteCallbacksCompletionCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RemoteCallbacksCompletionCallback)
 -> m (GClosure C_RemoteCallbacksCompletionCallback))
-> IO (GClosure C_RemoteCallbacksCompletionCallback)
-> m (GClosure C_RemoteCallbacksCompletionCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksCompletionCallback
cb' = RemoteCallbacksCompletionCallback
-> C_RemoteCallbacksCompletionCallback
wrap_RemoteCallbacksCompletionCallback RemoteCallbacksCompletionCallback
cb
    C_RemoteCallbacksCompletionCallback
-> IO (FunPtr C_RemoteCallbacksCompletionCallback)
mk_RemoteCallbacksCompletionCallback C_RemoteCallbacksCompletionCallback
cb' IO (FunPtr C_RemoteCallbacksCompletionCallback)
-> (FunPtr C_RemoteCallbacksCompletionCallback
    -> IO (GClosure C_RemoteCallbacksCompletionCallback))
-> IO (GClosure C_RemoteCallbacksCompletionCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RemoteCallbacksCompletionCallback
-> IO (GClosure C_RemoteCallbacksCompletionCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksCompletionCallback` into a `C_RemoteCallbacksCompletionCallback`.
wrap_RemoteCallbacksCompletionCallback ::
    RemoteCallbacksCompletionCallback ->
    C_RemoteCallbacksCompletionCallback
wrap_RemoteCallbacksCompletionCallback :: RemoteCallbacksCompletionCallback
-> C_RemoteCallbacksCompletionCallback
wrap_RemoteCallbacksCompletionCallback _cb :: RemoteCallbacksCompletionCallback
_cb _ object :: CUInt
object _ = do
    let object' :: RemoteCompletionType
object' = (Int -> RemoteCompletionType
forall a. Enum a => Int -> a
toEnum (Int -> RemoteCompletionType)
-> (CUInt -> Int) -> CUInt -> RemoteCompletionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
object
    RemoteCallbacksCompletionCallback
_cb  RemoteCompletionType
object'


-- | Connect a signal handler for the [completion](#signal:completion) 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' remoteCallbacks #completion callback
-- @
-- 
-- 
onRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
onRemoteCallbacksCompletion :: a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
onRemoteCallbacksCompletion obj :: a
obj cb :: RemoteCallbacksCompletionCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksCompletionCallback
cb' = RemoteCallbacksCompletionCallback
-> C_RemoteCallbacksCompletionCallback
wrap_RemoteCallbacksCompletionCallback RemoteCallbacksCompletionCallback
cb
    FunPtr C_RemoteCallbacksCompletionCallback
cb'' <- C_RemoteCallbacksCompletionCallback
-> IO (FunPtr C_RemoteCallbacksCompletionCallback)
mk_RemoteCallbacksCompletionCallback C_RemoteCallbacksCompletionCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksCompletionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "completion" FunPtr C_RemoteCallbacksCompletionCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [completion](#signal:completion) 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' remoteCallbacks #completion callback
-- @
-- 
-- 
afterRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
afterRemoteCallbacksCompletion :: a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
afterRemoteCallbacksCompletion obj :: a
obj cb :: RemoteCallbacksCompletionCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksCompletionCallback
cb' = RemoteCallbacksCompletionCallback
-> C_RemoteCallbacksCompletionCallback
wrap_RemoteCallbacksCompletionCallback RemoteCallbacksCompletionCallback
cb
    FunPtr C_RemoteCallbacksCompletionCallback
cb'' <- C_RemoteCallbacksCompletionCallback
-> IO (FunPtr C_RemoteCallbacksCompletionCallback)
mk_RemoteCallbacksCompletionCallback C_RemoteCallbacksCompletionCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksCompletionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "completion" FunPtr C_RemoteCallbacksCompletionCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data RemoteCallbacksCompletionSignalInfo
instance SignalInfo RemoteCallbacksCompletionSignalInfo where
    type HaskellCallbackType RemoteCallbacksCompletionSignalInfo = RemoteCallbacksCompletionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_RemoteCallbacksCompletionCallback cb
        cb'' <- mk_RemoteCallbacksCompletionCallback cb'
        connectSignalFunPtr obj "completion" cb'' connectMode detail

#endif

-- signal RemoteCallbacks::progress
-- | /No description available in the introspection data./
type RemoteCallbacksProgressCallback =
    T.Text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksProgressCallback`@.
noRemoteCallbacksProgressCallback :: Maybe RemoteCallbacksProgressCallback
noRemoteCallbacksProgressCallback :: Maybe RemoteCallbacksProgressCallback
noRemoteCallbacksProgressCallback = Maybe RemoteCallbacksProgressCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksProgressCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksProgress :: MonadIO m => RemoteCallbacksProgressCallback -> m (GClosure C_RemoteCallbacksProgressCallback)
genClosure_RemoteCallbacksProgress :: RemoteCallbacksProgressCallback
-> m (GClosure C_RemoteCallbacksProgressCallback)
genClosure_RemoteCallbacksProgress cb :: RemoteCallbacksProgressCallback
cb = IO (GClosure C_RemoteCallbacksProgressCallback)
-> m (GClosure C_RemoteCallbacksProgressCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RemoteCallbacksProgressCallback)
 -> m (GClosure C_RemoteCallbacksProgressCallback))
-> IO (GClosure C_RemoteCallbacksProgressCallback)
-> m (GClosure C_RemoteCallbacksProgressCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksProgressCallback
cb' = RemoteCallbacksProgressCallback
-> C_RemoteCallbacksProgressCallback
wrap_RemoteCallbacksProgressCallback RemoteCallbacksProgressCallback
cb
    C_RemoteCallbacksProgressCallback
-> IO (FunPtr C_RemoteCallbacksProgressCallback)
mk_RemoteCallbacksProgressCallback C_RemoteCallbacksProgressCallback
cb' IO (FunPtr C_RemoteCallbacksProgressCallback)
-> (FunPtr C_RemoteCallbacksProgressCallback
    -> IO (GClosure C_RemoteCallbacksProgressCallback))
-> IO (GClosure C_RemoteCallbacksProgressCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RemoteCallbacksProgressCallback
-> IO (GClosure C_RemoteCallbacksProgressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksProgressCallback` into a `C_RemoteCallbacksProgressCallback`.
wrap_RemoteCallbacksProgressCallback ::
    RemoteCallbacksProgressCallback ->
    C_RemoteCallbacksProgressCallback
wrap_RemoteCallbacksProgressCallback :: RemoteCallbacksProgressCallback
-> C_RemoteCallbacksProgressCallback
wrap_RemoteCallbacksProgressCallback _cb :: RemoteCallbacksProgressCallback
_cb _ object :: CString
object _ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    RemoteCallbacksProgressCallback
_cb  Text
object'


-- | Connect a signal handler for the [progress](#signal:progress) 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' remoteCallbacks #progress callback
-- @
-- 
-- 
onRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
onRemoteCallbacksProgress :: a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
onRemoteCallbacksProgress obj :: a
obj cb :: RemoteCallbacksProgressCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksProgressCallback
cb' = RemoteCallbacksProgressCallback
-> C_RemoteCallbacksProgressCallback
wrap_RemoteCallbacksProgressCallback RemoteCallbacksProgressCallback
cb
    FunPtr C_RemoteCallbacksProgressCallback
cb'' <- C_RemoteCallbacksProgressCallback
-> IO (FunPtr C_RemoteCallbacksProgressCallback)
mk_RemoteCallbacksProgressCallback C_RemoteCallbacksProgressCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksProgressCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "progress" FunPtr C_RemoteCallbacksProgressCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [progress](#signal:progress) 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' remoteCallbacks #progress callback
-- @
-- 
-- 
afterRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
afterRemoteCallbacksProgress :: a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
afterRemoteCallbacksProgress obj :: a
obj cb :: RemoteCallbacksProgressCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksProgressCallback
cb' = RemoteCallbacksProgressCallback
-> C_RemoteCallbacksProgressCallback
wrap_RemoteCallbacksProgressCallback RemoteCallbacksProgressCallback
cb
    FunPtr C_RemoteCallbacksProgressCallback
cb'' <- C_RemoteCallbacksProgressCallback
-> IO (FunPtr C_RemoteCallbacksProgressCallback)
mk_RemoteCallbacksProgressCallback C_RemoteCallbacksProgressCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksProgressCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "progress" FunPtr C_RemoteCallbacksProgressCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data RemoteCallbacksProgressSignalInfo
instance SignalInfo RemoteCallbacksProgressSignalInfo where
    type HaskellCallbackType RemoteCallbacksProgressSignalInfo = RemoteCallbacksProgressCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_RemoteCallbacksProgressCallback cb
        cb'' <- mk_RemoteCallbacksProgressCallback cb'
        connectSignalFunPtr obj "progress" cb'' connectMode detail

#endif

-- signal RemoteCallbacks::transfer-progress
-- | /No description available in the introspection data./
type RemoteCallbacksTransferProgressCallback =
    Ggit.TransferProgress.TransferProgress
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksTransferProgressCallback`@.
noRemoteCallbacksTransferProgressCallback :: Maybe RemoteCallbacksTransferProgressCallback
noRemoteCallbacksTransferProgressCallback :: Maybe RemoteCallbacksTransferProgressCallback
noRemoteCallbacksTransferProgressCallback = Maybe RemoteCallbacksTransferProgressCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksTransferProgressCallback =
    Ptr () ->                               -- object
    Ptr Ggit.TransferProgress.TransferProgress ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksTransferProgress :: MonadIO m => RemoteCallbacksTransferProgressCallback -> m (GClosure C_RemoteCallbacksTransferProgressCallback)
genClosure_RemoteCallbacksTransferProgress :: RemoteCallbacksTransferProgressCallback
-> m (GClosure C_RemoteCallbacksTransferProgressCallback)
genClosure_RemoteCallbacksTransferProgress cb :: RemoteCallbacksTransferProgressCallback
cb = IO (GClosure C_RemoteCallbacksTransferProgressCallback)
-> m (GClosure C_RemoteCallbacksTransferProgressCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RemoteCallbacksTransferProgressCallback)
 -> m (GClosure C_RemoteCallbacksTransferProgressCallback))
-> IO (GClosure C_RemoteCallbacksTransferProgressCallback)
-> m (GClosure C_RemoteCallbacksTransferProgressCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksTransferProgressCallback
cb' = RemoteCallbacksTransferProgressCallback
-> C_RemoteCallbacksTransferProgressCallback
wrap_RemoteCallbacksTransferProgressCallback RemoteCallbacksTransferProgressCallback
cb
    C_RemoteCallbacksTransferProgressCallback
-> IO (FunPtr C_RemoteCallbacksTransferProgressCallback)
mk_RemoteCallbacksTransferProgressCallback C_RemoteCallbacksTransferProgressCallback
cb' IO (FunPtr C_RemoteCallbacksTransferProgressCallback)
-> (FunPtr C_RemoteCallbacksTransferProgressCallback
    -> IO (GClosure C_RemoteCallbacksTransferProgressCallback))
-> IO (GClosure C_RemoteCallbacksTransferProgressCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RemoteCallbacksTransferProgressCallback
-> IO (GClosure C_RemoteCallbacksTransferProgressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksTransferProgressCallback` into a `C_RemoteCallbacksTransferProgressCallback`.
wrap_RemoteCallbacksTransferProgressCallback ::
    RemoteCallbacksTransferProgressCallback ->
    C_RemoteCallbacksTransferProgressCallback
wrap_RemoteCallbacksTransferProgressCallback :: RemoteCallbacksTransferProgressCallback
-> C_RemoteCallbacksTransferProgressCallback
wrap_RemoteCallbacksTransferProgressCallback _cb :: RemoteCallbacksTransferProgressCallback
_cb _ object :: Ptr TransferProgress
object _ = do
    (ManagedPtr TransferProgress -> TransferProgress)
-> Ptr TransferProgress
-> RemoteCallbacksTransferProgressCallback
-> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TransferProgress -> TransferProgress
Ggit.TransferProgress.TransferProgress Ptr TransferProgress
object (RemoteCallbacksTransferProgressCallback -> IO ())
-> RemoteCallbacksTransferProgressCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \object' :: TransferProgress
object' -> do
        RemoteCallbacksTransferProgressCallback
_cb  TransferProgress
object'


-- | Connect a signal handler for the [transferProgress](#signal:transferProgress) 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' remoteCallbacks #transferProgress callback
-- @
-- 
-- 
onRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
onRemoteCallbacksTransferProgress :: a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
onRemoteCallbacksTransferProgress obj :: a
obj cb :: RemoteCallbacksTransferProgressCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksTransferProgressCallback
cb' = RemoteCallbacksTransferProgressCallback
-> C_RemoteCallbacksTransferProgressCallback
wrap_RemoteCallbacksTransferProgressCallback RemoteCallbacksTransferProgressCallback
cb
    FunPtr C_RemoteCallbacksTransferProgressCallback
cb'' <- C_RemoteCallbacksTransferProgressCallback
-> IO (FunPtr C_RemoteCallbacksTransferProgressCallback)
mk_RemoteCallbacksTransferProgressCallback C_RemoteCallbacksTransferProgressCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksTransferProgressCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "transfer-progress" FunPtr C_RemoteCallbacksTransferProgressCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [transferProgress](#signal:transferProgress) 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' remoteCallbacks #transferProgress callback
-- @
-- 
-- 
afterRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
afterRemoteCallbacksTransferProgress :: a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
afterRemoteCallbacksTransferProgress obj :: a
obj cb :: RemoteCallbacksTransferProgressCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksTransferProgressCallback
cb' = RemoteCallbacksTransferProgressCallback
-> C_RemoteCallbacksTransferProgressCallback
wrap_RemoteCallbacksTransferProgressCallback RemoteCallbacksTransferProgressCallback
cb
    FunPtr C_RemoteCallbacksTransferProgressCallback
cb'' <- C_RemoteCallbacksTransferProgressCallback
-> IO (FunPtr C_RemoteCallbacksTransferProgressCallback)
mk_RemoteCallbacksTransferProgressCallback C_RemoteCallbacksTransferProgressCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksTransferProgressCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "transfer-progress" FunPtr C_RemoteCallbacksTransferProgressCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data RemoteCallbacksTransferProgressSignalInfo
instance SignalInfo RemoteCallbacksTransferProgressSignalInfo where
    type HaskellCallbackType RemoteCallbacksTransferProgressSignalInfo = RemoteCallbacksTransferProgressCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
        cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
        connectSignalFunPtr obj "transfer-progress" cb'' connectMode detail

#endif

-- signal RemoteCallbacks::update-tips
-- | /No description available in the introspection data./
type RemoteCallbacksUpdateTipsCallback =
    T.Text
    -> Ggit.OId.OId
    -> Ggit.OId.OId
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksUpdateTipsCallback`@.
noRemoteCallbacksUpdateTipsCallback :: Maybe RemoteCallbacksUpdateTipsCallback
noRemoteCallbacksUpdateTipsCallback :: Maybe RemoteCallbacksUpdateTipsCallback
noRemoteCallbacksUpdateTipsCallback = Maybe RemoteCallbacksUpdateTipsCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksUpdateTipsCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Ggit.OId.OId ->
    Ptr Ggit.OId.OId ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_RemoteCallbacksUpdateTips :: MonadIO m => RemoteCallbacksUpdateTipsCallback -> m (GClosure C_RemoteCallbacksUpdateTipsCallback)
genClosure_RemoteCallbacksUpdateTips :: RemoteCallbacksUpdateTipsCallback
-> m (GClosure C_RemoteCallbacksUpdateTipsCallback)
genClosure_RemoteCallbacksUpdateTips cb :: RemoteCallbacksUpdateTipsCallback
cb = IO (GClosure C_RemoteCallbacksUpdateTipsCallback)
-> m (GClosure C_RemoteCallbacksUpdateTipsCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RemoteCallbacksUpdateTipsCallback)
 -> m (GClosure C_RemoteCallbacksUpdateTipsCallback))
-> IO (GClosure C_RemoteCallbacksUpdateTipsCallback)
-> m (GClosure C_RemoteCallbacksUpdateTipsCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksUpdateTipsCallback
cb' = RemoteCallbacksUpdateTipsCallback
-> C_RemoteCallbacksUpdateTipsCallback
wrap_RemoteCallbacksUpdateTipsCallback RemoteCallbacksUpdateTipsCallback
cb
    C_RemoteCallbacksUpdateTipsCallback
-> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)
mk_RemoteCallbacksUpdateTipsCallback C_RemoteCallbacksUpdateTipsCallback
cb' IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)
-> (FunPtr C_RemoteCallbacksUpdateTipsCallback
    -> IO (GClosure C_RemoteCallbacksUpdateTipsCallback))
-> IO (GClosure C_RemoteCallbacksUpdateTipsCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RemoteCallbacksUpdateTipsCallback
-> IO (GClosure C_RemoteCallbacksUpdateTipsCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RemoteCallbacksUpdateTipsCallback` into a `C_RemoteCallbacksUpdateTipsCallback`.
wrap_RemoteCallbacksUpdateTipsCallback ::
    RemoteCallbacksUpdateTipsCallback ->
    C_RemoteCallbacksUpdateTipsCallback
wrap_RemoteCallbacksUpdateTipsCallback :: RemoteCallbacksUpdateTipsCallback
-> C_RemoteCallbacksUpdateTipsCallback
wrap_RemoteCallbacksUpdateTipsCallback _cb :: RemoteCallbacksUpdateTipsCallback
_cb _ object :: CString
object p0 :: Ptr OId
p0 p1 :: Ptr OId
p1 _ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    (ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
p0 ((OId -> IO ()) -> IO ()) -> (OId -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \p0' :: OId
p0' -> do
        (ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
p1 ((OId -> IO ()) -> IO ()) -> (OId -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \p1' :: OId
p1' -> do
            RemoteCallbacksUpdateTipsCallback
_cb  Text
object' OId
p0' OId
p1'


-- | Connect a signal handler for the [updateTips](#signal:updateTips) 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' remoteCallbacks #updateTips callback
-- @
-- 
-- 
onRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
onRemoteCallbacksUpdateTips :: a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
onRemoteCallbacksUpdateTips obj :: a
obj cb :: RemoteCallbacksUpdateTipsCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksUpdateTipsCallback
cb' = RemoteCallbacksUpdateTipsCallback
-> C_RemoteCallbacksUpdateTipsCallback
wrap_RemoteCallbacksUpdateTipsCallback RemoteCallbacksUpdateTipsCallback
cb
    FunPtr C_RemoteCallbacksUpdateTipsCallback
cb'' <- C_RemoteCallbacksUpdateTipsCallback
-> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)
mk_RemoteCallbacksUpdateTipsCallback C_RemoteCallbacksUpdateTipsCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksUpdateTipsCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "update-tips" FunPtr C_RemoteCallbacksUpdateTipsCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updateTips](#signal:updateTips) 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' remoteCallbacks #updateTips callback
-- @
-- 
-- 
afterRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
afterRemoteCallbacksUpdateTips :: a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
afterRemoteCallbacksUpdateTips obj :: a
obj cb :: RemoteCallbacksUpdateTipsCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_RemoteCallbacksUpdateTipsCallback
cb' = RemoteCallbacksUpdateTipsCallback
-> C_RemoteCallbacksUpdateTipsCallback
wrap_RemoteCallbacksUpdateTipsCallback RemoteCallbacksUpdateTipsCallback
cb
    FunPtr C_RemoteCallbacksUpdateTipsCallback
cb'' <- C_RemoteCallbacksUpdateTipsCallback
-> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)
mk_RemoteCallbacksUpdateTipsCallback C_RemoteCallbacksUpdateTipsCallback
cb'
    a
-> Text
-> FunPtr C_RemoteCallbacksUpdateTipsCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "update-tips" FunPtr C_RemoteCallbacksUpdateTipsCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data RemoteCallbacksUpdateTipsSignalInfo
instance SignalInfo RemoteCallbacksUpdateTipsSignalInfo where
    type HaskellCallbackType RemoteCallbacksUpdateTipsSignalInfo = RemoteCallbacksUpdateTipsCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
        cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
        connectSignalFunPtr obj "update-tips" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList RemoteCallbacks = RemoteCallbacksSignalList
type RemoteCallbacksSignalList = ('[ '("completion", RemoteCallbacksCompletionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("progress", RemoteCallbacksProgressSignalInfo), '("transferProgress", RemoteCallbacksTransferProgressSignalInfo), '("updateTips", RemoteCallbacksUpdateTipsSignalInfo)] :: [(Symbol, *)])

#endif