{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.DebugControllerDBus
(
DebugControllerDBus(..) ,
IsDebugControllerDBus ,
toDebugControllerDBus ,
#if defined(ENABLE_OVERLOADING)
ResolveDebugControllerDBusMethod ,
#endif
debugControllerDBusNew ,
#if defined(ENABLE_OVERLOADING)
DebugControllerDBusStopMethodInfo ,
#endif
debugControllerDBusStop ,
#if defined(ENABLE_OVERLOADING)
DebugControllerDBusConnectionPropertyInfo,
#endif
constructDebugControllerDBusConnection ,
#if defined(ENABLE_OVERLOADING)
debugControllerDBusConnection ,
#endif
getDebugControllerDBusConnection ,
DebugControllerDBusAuthorizeCallback ,
#if defined(ENABLE_OVERLOADING)
DebugControllerDBusAuthorizeSignalInfo ,
#endif
afterDebugControllerDBusAuthorize ,
onDebugControllerDBusAuthorize ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DebugController as Gio.DebugController
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Initable as Gio.Initable
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMethodInvocation as Gio.DBusMethodInvocation
newtype DebugControllerDBus = DebugControllerDBus (SP.ManagedPtr DebugControllerDBus)
deriving (DebugControllerDBus -> DebugControllerDBus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebugControllerDBus -> DebugControllerDBus -> Bool
$c/= :: DebugControllerDBus -> DebugControllerDBus -> Bool
== :: DebugControllerDBus -> DebugControllerDBus -> Bool
$c== :: DebugControllerDBus -> DebugControllerDBus -> Bool
Eq)
instance SP.ManagedPtrNewtype DebugControllerDBus where
toManagedPtr :: DebugControllerDBus -> ManagedPtr DebugControllerDBus
toManagedPtr (DebugControllerDBus ManagedPtr DebugControllerDBus
p) = ManagedPtr DebugControllerDBus
p
foreign import ccall "g_debug_controller_dbus_get_type"
c_g_debug_controller_dbus_get_type :: IO B.Types.GType
instance B.Types.TypedObject DebugControllerDBus where
glibType :: IO GType
glibType = IO GType
c_g_debug_controller_dbus_get_type
instance B.Types.GObject DebugControllerDBus
class (SP.GObject o, O.IsDescendantOf DebugControllerDBus o) => IsDebugControllerDBus o
instance (SP.GObject o, O.IsDescendantOf DebugControllerDBus o) => IsDebugControllerDBus o
instance O.HasParentTypes DebugControllerDBus
type instance O.ParentTypes DebugControllerDBus = '[GObject.Object.Object, Gio.DebugController.DebugController, Gio.Initable.Initable]
toDebugControllerDBus :: (MIO.MonadIO m, IsDebugControllerDBus o) => o -> m DebugControllerDBus
toDebugControllerDBus :: forall (m :: * -> *) o.
(MonadIO m, IsDebugControllerDBus o) =>
o -> m DebugControllerDBus
toDebugControllerDBus = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DebugControllerDBus -> DebugControllerDBus
DebugControllerDBus
instance B.GValue.IsGValue (Maybe DebugControllerDBus) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_debug_controller_dbus_get_type
gvalueSet_ :: Ptr GValue -> Maybe DebugControllerDBus -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DebugControllerDBus
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr DebugControllerDBus)
gvalueSet_ Ptr GValue
gv (P.Just DebugControllerDBus
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DebugControllerDBus
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DebugControllerDBus)
gvalueGet_ Ptr GValue
gv = do
Ptr DebugControllerDBus
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DebugControllerDBus)
if Ptr DebugControllerDBus
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DebugControllerDBus -> DebugControllerDBus
DebugControllerDBus Ptr DebugControllerDBus
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDebugControllerDBusMethod (t :: Symbol) (o :: *) :: * where
ResolveDebugControllerDBusMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDebugControllerDBusMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDebugControllerDBusMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDebugControllerDBusMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDebugControllerDBusMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDebugControllerDBusMethod "init" o = Gio.Initable.InitableInitMethodInfo
ResolveDebugControllerDBusMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDebugControllerDBusMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDebugControllerDBusMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDebugControllerDBusMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDebugControllerDBusMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDebugControllerDBusMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDebugControllerDBusMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDebugControllerDBusMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDebugControllerDBusMethod "stop" o = DebugControllerDBusStopMethodInfo
ResolveDebugControllerDBusMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDebugControllerDBusMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDebugControllerDBusMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDebugControllerDBusMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDebugControllerDBusMethod "getDebugEnabled" o = Gio.DebugController.DebugControllerGetDebugEnabledMethodInfo
ResolveDebugControllerDBusMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDebugControllerDBusMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDebugControllerDBusMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDebugControllerDBusMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDebugControllerDBusMethod "setDebugEnabled" o = Gio.DebugController.DebugControllerSetDebugEnabledMethodInfo
ResolveDebugControllerDBusMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDebugControllerDBusMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDebugControllerDBusMethod t DebugControllerDBus, O.OverloadedMethod info DebugControllerDBus p) => OL.IsLabel t (DebugControllerDBus -> 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 ~ ResolveDebugControllerDBusMethod t DebugControllerDBus, O.OverloadedMethod info DebugControllerDBus p, R.HasField t DebugControllerDBus p) => R.HasField t DebugControllerDBus p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDebugControllerDBusMethod t DebugControllerDBus, O.OverloadedMethodInfo info DebugControllerDBus) => OL.IsLabel t (O.MethodProxy info DebugControllerDBus) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type DebugControllerDBusAuthorizeCallback =
Gio.DBusMethodInvocation.DBusMethodInvocation
-> IO Bool
type C_DebugControllerDBusAuthorizeCallback =
Ptr DebugControllerDBus ->
Ptr Gio.DBusMethodInvocation.DBusMethodInvocation ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_DebugControllerDBusAuthorizeCallback :: C_DebugControllerDBusAuthorizeCallback -> IO (FunPtr C_DebugControllerDBusAuthorizeCallback)
wrap_DebugControllerDBusAuthorizeCallback ::
GObject a => (a -> DebugControllerDBusAuthorizeCallback) ->
C_DebugControllerDBusAuthorizeCallback
wrap_DebugControllerDBusAuthorizeCallback :: forall a.
GObject a =>
(a -> DebugControllerDBusAuthorizeCallback)
-> C_DebugControllerDBusAuthorizeCallback
wrap_DebugControllerDBusAuthorizeCallback a -> DebugControllerDBusAuthorizeCallback
gi'cb Ptr DebugControllerDBus
gi'selfPtr Ptr DBusMethodInvocation
invocation Ptr ()
_ = do
DBusMethodInvocation
invocation' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusMethodInvocation -> DBusMethodInvocation
Gio.DBusMethodInvocation.DBusMethodInvocation) Ptr DBusMethodInvocation
invocation
Bool
result <- forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DebugControllerDBus
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \DebugControllerDBus
gi'self -> a -> DebugControllerDBusAuthorizeCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce DebugControllerDBus
gi'self) DBusMethodInvocation
invocation'
let result' :: CInt
result' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
result
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
onDebugControllerDBusAuthorize :: (IsDebugControllerDBus a, MonadIO m) => a -> ((?self :: a) => DebugControllerDBusAuthorizeCallback) -> m SignalHandlerId
onDebugControllerDBusAuthorize :: forall a (m :: * -> *).
(IsDebugControllerDBus a, MonadIO m) =>
a
-> ((?self::a) => DebugControllerDBusAuthorizeCallback)
-> m SignalHandlerId
onDebugControllerDBusAuthorize a
obj (?self::a) => DebugControllerDBusAuthorizeCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> DebugControllerDBusAuthorizeCallback
wrapped a
self = let ?self = a
self in (?self::a) => DebugControllerDBusAuthorizeCallback
cb
let wrapped' :: C_DebugControllerDBusAuthorizeCallback
wrapped' = forall a.
GObject a =>
(a -> DebugControllerDBusAuthorizeCallback)
-> C_DebugControllerDBusAuthorizeCallback
wrap_DebugControllerDBusAuthorizeCallback a -> DebugControllerDBusAuthorizeCallback
wrapped
FunPtr C_DebugControllerDBusAuthorizeCallback
wrapped'' <- C_DebugControllerDBusAuthorizeCallback
-> IO (FunPtr C_DebugControllerDBusAuthorizeCallback)
mk_DebugControllerDBusAuthorizeCallback C_DebugControllerDBusAuthorizeCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"authorize" FunPtr C_DebugControllerDBusAuthorizeCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterDebugControllerDBusAuthorize :: (IsDebugControllerDBus a, MonadIO m) => a -> ((?self :: a) => DebugControllerDBusAuthorizeCallback) -> m SignalHandlerId
afterDebugControllerDBusAuthorize :: forall a (m :: * -> *).
(IsDebugControllerDBus a, MonadIO m) =>
a
-> ((?self::a) => DebugControllerDBusAuthorizeCallback)
-> m SignalHandlerId
afterDebugControllerDBusAuthorize a
obj (?self::a) => DebugControllerDBusAuthorizeCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> DebugControllerDBusAuthorizeCallback
wrapped a
self = let ?self = a
self in (?self::a) => DebugControllerDBusAuthorizeCallback
cb
let wrapped' :: C_DebugControllerDBusAuthorizeCallback
wrapped' = forall a.
GObject a =>
(a -> DebugControllerDBusAuthorizeCallback)
-> C_DebugControllerDBusAuthorizeCallback
wrap_DebugControllerDBusAuthorizeCallback a -> DebugControllerDBusAuthorizeCallback
wrapped
FunPtr C_DebugControllerDBusAuthorizeCallback
wrapped'' <- C_DebugControllerDBusAuthorizeCallback
-> IO (FunPtr C_DebugControllerDBusAuthorizeCallback)
mk_DebugControllerDBusAuthorizeCallback C_DebugControllerDBusAuthorizeCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"authorize" FunPtr C_DebugControllerDBusAuthorizeCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DebugControllerDBusAuthorizeSignalInfo
instance SignalInfo DebugControllerDBusAuthorizeSignalInfo where
type HaskellCallbackType DebugControllerDBusAuthorizeSignalInfo = DebugControllerDBusAuthorizeCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DebugControllerDBusAuthorizeCallback cb
cb'' <- mk_DebugControllerDBusAuthorizeCallback cb'
connectSignalFunPtr obj "authorize" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DebugControllerDBus::authorize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-DebugControllerDBus.html#g:signal:authorize"})
#endif
getDebugControllerDBusConnection :: (MonadIO m, IsDebugControllerDBus o) => o -> m (Maybe Gio.DBusConnection.DBusConnection)
getDebugControllerDBusConnection :: forall (m :: * -> *) o.
(MonadIO m, IsDebugControllerDBus o) =>
o -> m (Maybe DBusConnection)
getDebugControllerDBusConnection o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"connection" ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection
constructDebugControllerDBusConnection :: (IsDebugControllerDBus o, MIO.MonadIO m, Gio.DBusConnection.IsDBusConnection a) => a -> m (GValueConstruct o)
constructDebugControllerDBusConnection :: forall o (m :: * -> *) a.
(IsDebugControllerDBus o, MonadIO m, IsDBusConnection a) =>
a -> m (GValueConstruct o)
constructDebugControllerDBusConnection a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"connection" (forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data DebugControllerDBusConnectionPropertyInfo
instance AttrInfo DebugControllerDBusConnectionPropertyInfo where
type AttrAllowedOps DebugControllerDBusConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint DebugControllerDBusConnectionPropertyInfo = IsDebugControllerDBus
type AttrSetTypeConstraint DebugControllerDBusConnectionPropertyInfo = Gio.DBusConnection.IsDBusConnection
type AttrTransferTypeConstraint DebugControllerDBusConnectionPropertyInfo = Gio.DBusConnection.IsDBusConnection
type AttrTransferType DebugControllerDBusConnectionPropertyInfo = Gio.DBusConnection.DBusConnection
type AttrGetType DebugControllerDBusConnectionPropertyInfo = (Maybe Gio.DBusConnection.DBusConnection)
type AttrLabel DebugControllerDBusConnectionPropertyInfo = "connection"
type AttrOrigin DebugControllerDBusConnectionPropertyInfo = DebugControllerDBus
attrGet = getDebugControllerDBusConnection
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Gio.DBusConnection.DBusConnection v
attrConstruct = constructDebugControllerDBusConnection
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DebugControllerDBus.connection"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-DebugControllerDBus.html#g:attr:connection"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DebugControllerDBus
type instance O.AttributeList DebugControllerDBus = DebugControllerDBusAttributeList
type DebugControllerDBusAttributeList = ('[ '("connection", DebugControllerDBusConnectionPropertyInfo), '("debugEnabled", Gio.DebugController.DebugControllerDebugEnabledPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
debugControllerDBusConnection :: AttrLabelProxy "connection"
debugControllerDBusConnection = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DebugControllerDBus = DebugControllerDBusSignalList
type DebugControllerDBusSignalList = ('[ '("authorize", DebugControllerDBusAuthorizeSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_debug_controller_dbus_new" g_debug_controller_dbus_new ::
Ptr Gio.DBusConnection.DBusConnection ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr DebugControllerDBus)
debugControllerDBusNew ::
(B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m (Maybe DebugControllerDBus)
debugControllerDBusNew :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b) =>
a -> Maybe b -> m (Maybe DebugControllerDBus)
debugControllerDBusNew a
connection Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusConnection
connection' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Ptr DebugControllerDBus
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr DBusConnection
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr DebugControllerDBus)
g_debug_controller_dbus_new Ptr DBusConnection
connection' Ptr Cancellable
maybeCancellable
Maybe DebugControllerDBus
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DebugControllerDBus
result forall a b. (a -> b) -> a -> b
$ \Ptr DebugControllerDBus
result' -> do
DebugControllerDBus
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DebugControllerDBus -> DebugControllerDBus
DebugControllerDBus) Ptr DebugControllerDBus
result'
forall (m :: * -> *) a. Monad m => a -> m a
return DebugControllerDBus
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DebugControllerDBus
maybeResult
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_debug_controller_dbus_stop" g_debug_controller_dbus_stop ::
Ptr DebugControllerDBus ->
IO ()
debugControllerDBusStop ::
(B.CallStack.HasCallStack, MonadIO m, IsDebugControllerDBus a) =>
a
-> m ()
debugControllerDBusStop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDebugControllerDBus a) =>
a -> m ()
debugControllerDBusStop a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DebugControllerDBus
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr DebugControllerDBus -> IO ()
g_debug_controller_dbus_stop Ptr DebugControllerDBus
self'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DebugControllerDBusStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDebugControllerDBus a) => O.OverloadedMethod DebugControllerDBusStopMethodInfo a signature where
overloadedMethod = debugControllerDBusStop
instance O.OverloadedMethodInfo DebugControllerDBusStopMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DebugControllerDBus.debugControllerDBusStop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-DebugControllerDBus.html#v:debugControllerDBusStop"
})
#endif