{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.DBusInterfaceSkeleton
(
DBusInterfaceSkeleton(..) ,
IsDBusInterfaceSkeleton ,
toDBusInterfaceSkeleton ,
#if defined(ENABLE_OVERLOADING)
ResolveDBusInterfaceSkeletonMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonExportMethodInfo ,
#endif
dBusInterfaceSkeletonExport ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonFlushMethodInfo ,
#endif
dBusInterfaceSkeletonFlush ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetConnectionMethodInfo,
#endif
dBusInterfaceSkeletonGetConnection ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetConnectionsMethodInfo,
#endif
dBusInterfaceSkeletonGetConnections ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetFlagsMethodInfo ,
#endif
dBusInterfaceSkeletonGetFlags ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetInfoMethodInfo ,
#endif
dBusInterfaceSkeletonGetInfo ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetObjectPathMethodInfo,
#endif
dBusInterfaceSkeletonGetObjectPath ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetPropertiesMethodInfo,
#endif
dBusInterfaceSkeletonGetProperties ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGetVtableMethodInfo,
#endif
dBusInterfaceSkeletonGetVtable ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonHasConnectionMethodInfo,
#endif
dBusInterfaceSkeletonHasConnection ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonSetFlagsMethodInfo ,
#endif
dBusInterfaceSkeletonSetFlags ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonUnexportMethodInfo ,
#endif
dBusInterfaceSkeletonUnexport ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonUnexportFromConnectionMethodInfo,
#endif
dBusInterfaceSkeletonUnexportFromConnection,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGFlagsPropertyInfo ,
#endif
constructDBusInterfaceSkeletonGFlags ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceSkeletonGFlags ,
#endif
getDBusInterfaceSkeletonGFlags ,
setDBusInterfaceSkeletonGFlags ,
DBusInterfaceSkeletonGAuthorizeMethodCallback,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceSkeletonGAuthorizeMethodSignalInfo,
#endif
afterDBusInterfaceSkeletonGAuthorizeMethod,
onDBusInterfaceSkeletonGAuthorizeMethod ,
) 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
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.Parameter as GObject.Parameter
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusInterface as Gio.DBusInterface
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusObject as Gio.DBusObject
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.Credentials as Gio.Credentials
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusAuthObserver as Gio.DBusAuthObserver
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMessage as Gio.DBusMessage
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMethodInvocation as Gio.DBusMethodInvocation
import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuAttributeIter as Gio.MenuAttributeIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuLinkIter as Gio.MenuLinkIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusAnnotationInfo as Gio.DBusAnnotationInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusArgInfo as Gio.DBusArgInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceVTable as Gio.DBusInterfaceVTable
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusMethodInfo as Gio.DBusMethodInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusPropertyInfo as Gio.DBusPropertyInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusSignalInfo as Gio.DBusSignalInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusSubtreeVTable as Gio.DBusSubtreeVTable
import {-# SOURCE #-} qualified GI.Gio.Structs.OutputVector as Gio.OutputVector
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusInterface as Gio.DBusInterface
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMethodInvocation as Gio.DBusMethodInvocation
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceVTable as Gio.DBusInterfaceVTable
#endif
newtype DBusInterfaceSkeleton = DBusInterfaceSkeleton (SP.ManagedPtr DBusInterfaceSkeleton)
deriving (DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool
(DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool)
-> (DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool)
-> Eq DBusInterfaceSkeleton
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool
== :: DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool
$c/= :: DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool
/= :: DBusInterfaceSkeleton -> DBusInterfaceSkeleton -> Bool
Eq)
instance SP.ManagedPtrNewtype DBusInterfaceSkeleton where
toManagedPtr :: DBusInterfaceSkeleton -> ManagedPtr DBusInterfaceSkeleton
toManagedPtr (DBusInterfaceSkeleton ManagedPtr DBusInterfaceSkeleton
p) = ManagedPtr DBusInterfaceSkeleton
p
foreign import ccall "g_dbus_interface_skeleton_get_type"
c_g_dbus_interface_skeleton_get_type :: IO B.Types.GType
instance B.Types.TypedObject DBusInterfaceSkeleton where
glibType :: IO GType
glibType = IO GType
c_g_dbus_interface_skeleton_get_type
instance B.Types.GObject DBusInterfaceSkeleton
class (SP.GObject o, O.IsDescendantOf DBusInterfaceSkeleton o) => IsDBusInterfaceSkeleton o
instance (SP.GObject o, O.IsDescendantOf DBusInterfaceSkeleton o) => IsDBusInterfaceSkeleton o
instance O.HasParentTypes DBusInterfaceSkeleton
type instance O.ParentTypes DBusInterfaceSkeleton = '[GObject.Object.Object, Gio.DBusInterface.DBusInterface]
toDBusInterfaceSkeleton :: (MIO.MonadIO m, IsDBusInterfaceSkeleton o) => o -> m DBusInterfaceSkeleton
toDBusInterfaceSkeleton :: forall (m :: * -> *) o.
(MonadIO m, IsDBusInterfaceSkeleton o) =>
o -> m DBusInterfaceSkeleton
toDBusInterfaceSkeleton = IO DBusInterfaceSkeleton -> m DBusInterfaceSkeleton
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DBusInterfaceSkeleton -> m DBusInterfaceSkeleton)
-> (o -> IO DBusInterfaceSkeleton) -> o -> m DBusInterfaceSkeleton
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DBusInterfaceSkeleton -> DBusInterfaceSkeleton)
-> o -> IO DBusInterfaceSkeleton
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DBusInterfaceSkeleton -> DBusInterfaceSkeleton
DBusInterfaceSkeleton
instance B.GValue.IsGValue (Maybe DBusInterfaceSkeleton) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_dbus_interface_skeleton_get_type
gvalueSet_ :: Ptr GValue -> Maybe DBusInterfaceSkeleton -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DBusInterfaceSkeleton
P.Nothing = Ptr GValue -> Ptr DBusInterfaceSkeleton -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DBusInterfaceSkeleton
forall a. Ptr a
FP.nullPtr :: FP.Ptr DBusInterfaceSkeleton)
gvalueSet_ Ptr GValue
gv (P.Just DBusInterfaceSkeleton
obj) = DBusInterfaceSkeleton
-> (Ptr DBusInterfaceSkeleton -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DBusInterfaceSkeleton
obj (Ptr GValue -> Ptr DBusInterfaceSkeleton -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DBusInterfaceSkeleton)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr DBusInterfaceSkeleton)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DBusInterfaceSkeleton)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject DBusInterfaceSkeleton ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDBusInterfaceSkeletonMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDBusInterfaceSkeletonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDBusInterfaceSkeletonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDBusInterfaceSkeletonMethod "export" o = DBusInterfaceSkeletonExportMethodInfo
ResolveDBusInterfaceSkeletonMethod "flush" o = DBusInterfaceSkeletonFlushMethodInfo
ResolveDBusInterfaceSkeletonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDBusInterfaceSkeletonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDBusInterfaceSkeletonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDBusInterfaceSkeletonMethod "hasConnection" o = DBusInterfaceSkeletonHasConnectionMethodInfo
ResolveDBusInterfaceSkeletonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDBusInterfaceSkeletonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDBusInterfaceSkeletonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDBusInterfaceSkeletonMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDBusInterfaceSkeletonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDBusInterfaceSkeletonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDBusInterfaceSkeletonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDBusInterfaceSkeletonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDBusInterfaceSkeletonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDBusInterfaceSkeletonMethod "unexport" o = DBusInterfaceSkeletonUnexportMethodInfo
ResolveDBusInterfaceSkeletonMethod "unexportFromConnection" o = DBusInterfaceSkeletonUnexportFromConnectionMethodInfo
ResolveDBusInterfaceSkeletonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDBusInterfaceSkeletonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDBusInterfaceSkeletonMethod "getConnection" o = DBusInterfaceSkeletonGetConnectionMethodInfo
ResolveDBusInterfaceSkeletonMethod "getConnections" o = DBusInterfaceSkeletonGetConnectionsMethodInfo
ResolveDBusInterfaceSkeletonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDBusInterfaceSkeletonMethod "getFlags" o = DBusInterfaceSkeletonGetFlagsMethodInfo
ResolveDBusInterfaceSkeletonMethod "getInfo" o = DBusInterfaceSkeletonGetInfoMethodInfo
ResolveDBusInterfaceSkeletonMethod "getObject" o = Gio.DBusInterface.DBusInterfaceGetObjectMethodInfo
ResolveDBusInterfaceSkeletonMethod "getObjectPath" o = DBusInterfaceSkeletonGetObjectPathMethodInfo
ResolveDBusInterfaceSkeletonMethod "getProperties" o = DBusInterfaceSkeletonGetPropertiesMethodInfo
ResolveDBusInterfaceSkeletonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDBusInterfaceSkeletonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDBusInterfaceSkeletonMethod "getVtable" o = DBusInterfaceSkeletonGetVtableMethodInfo
ResolveDBusInterfaceSkeletonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDBusInterfaceSkeletonMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDBusInterfaceSkeletonMethod "setFlags" o = DBusInterfaceSkeletonSetFlagsMethodInfo
ResolveDBusInterfaceSkeletonMethod "setObject" o = Gio.DBusInterface.DBusInterfaceSetObjectMethodInfo
ResolveDBusInterfaceSkeletonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDBusInterfaceSkeletonMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDBusInterfaceSkeletonMethod t DBusInterfaceSkeleton, O.OverloadedMethod info DBusInterfaceSkeleton p) => OL.IsLabel t (DBusInterfaceSkeleton -> 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 ~ ResolveDBusInterfaceSkeletonMethod t DBusInterfaceSkeleton, O.OverloadedMethod info DBusInterfaceSkeleton p, R.HasField t DBusInterfaceSkeleton p) => R.HasField t DBusInterfaceSkeleton p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDBusInterfaceSkeletonMethod t DBusInterfaceSkeleton, O.OverloadedMethodInfo info DBusInterfaceSkeleton) => OL.IsLabel t (O.MethodProxy info DBusInterfaceSkeleton) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type DBusInterfaceSkeletonGAuthorizeMethodCallback =
Gio.DBusMethodInvocation.DBusMethodInvocation
-> IO Bool
type C_DBusInterfaceSkeletonGAuthorizeMethodCallback =
Ptr DBusInterfaceSkeleton ->
Ptr Gio.DBusMethodInvocation.DBusMethodInvocation ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_DBusInterfaceSkeletonGAuthorizeMethodCallback :: C_DBusInterfaceSkeletonGAuthorizeMethodCallback -> IO (FunPtr C_DBusInterfaceSkeletonGAuthorizeMethodCallback)
wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback ::
GObject a => (a -> DBusInterfaceSkeletonGAuthorizeMethodCallback) ->
C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback :: forall a.
GObject a =>
(a -> DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback a -> DBusInterfaceSkeletonGAuthorizeMethodCallback
gi'cb Ptr DBusInterfaceSkeleton
gi'selfPtr Ptr DBusMethodInvocation
invocation Ptr ()
_ = do
invocation' <- ((ManagedPtr DBusMethodInvocation -> DBusMethodInvocation)
-> Ptr DBusMethodInvocation -> IO DBusMethodInvocation
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
result <- B.ManagedPtr.withNewObject gi'selfPtr $ \DBusInterfaceSkeleton
gi'self -> a -> DBusInterfaceSkeletonGAuthorizeMethodCallback
gi'cb (DBusInterfaceSkeleton -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DBusInterfaceSkeleton
gi'self) DBusMethodInvocation
invocation'
let 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
return result'
onDBusInterfaceSkeletonGAuthorizeMethod :: (IsDBusInterfaceSkeleton a, MonadIO m) => a -> ((?self :: a) => DBusInterfaceSkeletonGAuthorizeMethodCallback) -> m SignalHandlerId
onDBusInterfaceSkeletonGAuthorizeMethod :: forall a (m :: * -> *).
(IsDBusInterfaceSkeleton a, MonadIO m) =>
a
-> ((?self::a) => DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> m SignalHandlerId
onDBusInterfaceSkeletonGAuthorizeMethod a
obj (?self::a) => DBusInterfaceSkeletonGAuthorizeMethodCallback
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 -> DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DBusInterfaceSkeletonGAuthorizeMethodCallback
DBusInterfaceSkeletonGAuthorizeMethodCallback
cb
let wrapped' :: C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped' = (a -> DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> C_DBusInterfaceSkeletonGAuthorizeMethodCallback
forall a.
GObject a =>
(a -> DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback a -> DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped
wrapped'' <- C_DBusInterfaceSkeletonGAuthorizeMethodCallback
-> IO (FunPtr C_DBusInterfaceSkeletonGAuthorizeMethodCallback)
mk_DBusInterfaceSkeletonGAuthorizeMethodCallback C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped'
connectSignalFunPtr obj "g-authorize-method" wrapped'' SignalConnectBefore Nothing
afterDBusInterfaceSkeletonGAuthorizeMethod :: (IsDBusInterfaceSkeleton a, MonadIO m) => a -> ((?self :: a) => DBusInterfaceSkeletonGAuthorizeMethodCallback) -> m SignalHandlerId
afterDBusInterfaceSkeletonGAuthorizeMethod :: forall a (m :: * -> *).
(IsDBusInterfaceSkeleton a, MonadIO m) =>
a
-> ((?self::a) => DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> m SignalHandlerId
afterDBusInterfaceSkeletonGAuthorizeMethod a
obj (?self::a) => DBusInterfaceSkeletonGAuthorizeMethodCallback
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 -> DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DBusInterfaceSkeletonGAuthorizeMethodCallback
DBusInterfaceSkeletonGAuthorizeMethodCallback
cb
let wrapped' :: C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped' = (a -> DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> C_DBusInterfaceSkeletonGAuthorizeMethodCallback
forall a.
GObject a =>
(a -> DBusInterfaceSkeletonGAuthorizeMethodCallback)
-> C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback a -> DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped
wrapped'' <- C_DBusInterfaceSkeletonGAuthorizeMethodCallback
-> IO (FunPtr C_DBusInterfaceSkeletonGAuthorizeMethodCallback)
mk_DBusInterfaceSkeletonGAuthorizeMethodCallback C_DBusInterfaceSkeletonGAuthorizeMethodCallback
wrapped'
connectSignalFunPtr obj "g-authorize-method" wrapped'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGAuthorizeMethodSignalInfo
instance SignalInfo DBusInterfaceSkeletonGAuthorizeMethodSignalInfo where
type HaskellCallbackType DBusInterfaceSkeletonGAuthorizeMethodSignalInfo = DBusInterfaceSkeletonGAuthorizeMethodCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb
cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb'
connectSignalFunPtr obj "g-authorize-method" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton::g-authorize-method"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#g:signal:gAuthorizeMethod"})
#endif
getDBusInterfaceSkeletonGFlags :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> m [Gio.Flags.DBusInterfaceSkeletonFlags]
getDBusInterfaceSkeletonGFlags :: forall (m :: * -> *) o.
(MonadIO m, IsDBusInterfaceSkeleton o) =>
o -> m [DBusInterfaceSkeletonFlags]
getDBusInterfaceSkeletonGFlags o
obj = IO [DBusInterfaceSkeletonFlags] -> m [DBusInterfaceSkeletonFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [DBusInterfaceSkeletonFlags] -> m [DBusInterfaceSkeletonFlags])
-> IO [DBusInterfaceSkeletonFlags]
-> m [DBusInterfaceSkeletonFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [DBusInterfaceSkeletonFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"g-flags"
setDBusInterfaceSkeletonGFlags :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> [Gio.Flags.DBusInterfaceSkeletonFlags] -> m ()
setDBusInterfaceSkeletonGFlags :: forall (m :: * -> *) o.
(MonadIO m, IsDBusInterfaceSkeleton o) =>
o -> [DBusInterfaceSkeletonFlags] -> m ()
setDBusInterfaceSkeletonGFlags o
obj [DBusInterfaceSkeletonFlags]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> [DBusInterfaceSkeletonFlags] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"g-flags" [DBusInterfaceSkeletonFlags]
val
constructDBusInterfaceSkeletonGFlags :: (IsDBusInterfaceSkeleton o, MIO.MonadIO m) => [Gio.Flags.DBusInterfaceSkeletonFlags] -> m (GValueConstruct o)
constructDBusInterfaceSkeletonGFlags :: forall o (m :: * -> *).
(IsDBusInterfaceSkeleton o, MonadIO m) =>
[DBusInterfaceSkeletonFlags] -> m (GValueConstruct o)
constructDBusInterfaceSkeletonGFlags [DBusInterfaceSkeletonFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [DBusInterfaceSkeletonFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"g-flags" [DBusInterfaceSkeletonFlags]
val
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGFlagsPropertyInfo
instance AttrInfo DBusInterfaceSkeletonGFlagsPropertyInfo where
type AttrAllowedOps DBusInterfaceSkeletonGFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = IsDBusInterfaceSkeleton
type AttrSetTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = (~) [Gio.Flags.DBusInterfaceSkeletonFlags]
type AttrTransferTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = (~) [Gio.Flags.DBusInterfaceSkeletonFlags]
type AttrTransferType DBusInterfaceSkeletonGFlagsPropertyInfo = [Gio.Flags.DBusInterfaceSkeletonFlags]
type AttrGetType DBusInterfaceSkeletonGFlagsPropertyInfo = [Gio.Flags.DBusInterfaceSkeletonFlags]
type AttrLabel DBusInterfaceSkeletonGFlagsPropertyInfo = "g-flags"
type AttrOrigin DBusInterfaceSkeletonGFlagsPropertyInfo = DBusInterfaceSkeleton
attrGet = getDBusInterfaceSkeletonGFlags
attrSet = setDBusInterfaceSkeletonGFlags
attrTransfer _ v = do
return v
attrConstruct = constructDBusInterfaceSkeletonGFlags
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.gFlags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#g:attr:gFlags"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DBusInterfaceSkeleton
type instance O.AttributeList DBusInterfaceSkeleton = DBusInterfaceSkeletonAttributeList
type DBusInterfaceSkeletonAttributeList = ('[ '("gFlags", DBusInterfaceSkeletonGFlagsPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
dBusInterfaceSkeletonGFlags :: AttrLabelProxy "gFlags"
dBusInterfaceSkeletonGFlags = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DBusInterfaceSkeleton = DBusInterfaceSkeletonSignalList
type DBusInterfaceSkeletonSignalList = ('[ '("gAuthorizeMethod", DBusInterfaceSkeletonGAuthorizeMethodSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_dbus_interface_skeleton_export" g_dbus_interface_skeleton_export ::
Ptr DBusInterfaceSkeleton ->
Ptr Gio.DBusConnection.DBusConnection ->
CString ->
Ptr (Ptr GError) ->
IO CInt
dBusInterfaceSkeletonExport ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) =>
a
-> b
-> T.Text
-> m ()
dBusInterfaceSkeletonExport :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a,
IsDBusConnection b) =>
a -> b -> Text -> m ()
dBusInterfaceSkeletonExport a
interface_ b
connection Text
objectPath = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
connection' <- unsafeManagedPtrCastPtr connection
objectPath' <- textToCString objectPath
onException (do
_ <- propagateGError $ g_dbus_interface_skeleton_export interface_' connection' objectPath'
touchManagedPtr interface_
touchManagedPtr connection
freeMem objectPath'
return ()
) (do
freeMem objectPath'
)
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonExportMethodInfo
instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.OverloadedMethod DBusInterfaceSkeletonExportMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonExport
instance O.OverloadedMethodInfo DBusInterfaceSkeletonExportMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonExport",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonExport"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_flush" g_dbus_interface_skeleton_flush ::
Ptr DBusInterfaceSkeleton ->
IO ()
dBusInterfaceSkeletonFlush ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m ()
dBusInterfaceSkeletonFlush :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m ()
dBusInterfaceSkeletonFlush a
interface_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
g_dbus_interface_skeleton_flush interface_'
touchManagedPtr interface_
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonFlushMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonFlushMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonFlush
instance O.OverloadedMethodInfo DBusInterfaceSkeletonFlushMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonFlush",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonFlush"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_connection" g_dbus_interface_skeleton_get_connection ::
Ptr DBusInterfaceSkeleton ->
IO (Ptr Gio.DBusConnection.DBusConnection)
dBusInterfaceSkeletonGetConnection ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m (Maybe Gio.DBusConnection.DBusConnection)
dBusInterfaceSkeletonGetConnection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m (Maybe DBusConnection)
dBusInterfaceSkeletonGetConnection a
interface_ = IO (Maybe DBusConnection) -> m (Maybe DBusConnection)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DBusConnection) -> m (Maybe DBusConnection))
-> IO (Maybe DBusConnection) -> m (Maybe DBusConnection)
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_connection interface_'
maybeResult <- convertIfNonNull result $ \Ptr DBusConnection
result' -> do
result'' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
result'
return result''
touchManagedPtr interface_
return maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetConnectionMethodInfo
instance (signature ~ (m (Maybe Gio.DBusConnection.DBusConnection)), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetConnectionMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetConnection
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetConnectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetConnection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetConnection"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_connections" g_dbus_interface_skeleton_get_connections ::
Ptr DBusInterfaceSkeleton ->
IO (Ptr (GList (Ptr Gio.DBusConnection.DBusConnection)))
dBusInterfaceSkeletonGetConnections ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m [Gio.DBusConnection.DBusConnection]
dBusInterfaceSkeletonGetConnections :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m [DBusConnection]
dBusInterfaceSkeletonGetConnections a
interface_ = IO [DBusConnection] -> m [DBusConnection]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [DBusConnection] -> m [DBusConnection])
-> IO [DBusConnection] -> m [DBusConnection]
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_connections interface_'
result' <- unpackGList result
result'' <- mapM (wrapObject Gio.DBusConnection.DBusConnection) result'
g_list_free result
touchManagedPtr interface_
return result''
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetConnectionsMethodInfo
instance (signature ~ (m [Gio.DBusConnection.DBusConnection]), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetConnectionsMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetConnections
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetConnectionsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetConnections",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetConnections"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_flags" g_dbus_interface_skeleton_get_flags ::
Ptr DBusInterfaceSkeleton ->
IO CUInt
dBusInterfaceSkeletonGetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m [Gio.Flags.DBusInterfaceSkeletonFlags]
dBusInterfaceSkeletonGetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m [DBusInterfaceSkeletonFlags]
dBusInterfaceSkeletonGetFlags a
interface_ = IO [DBusInterfaceSkeletonFlags] -> m [DBusInterfaceSkeletonFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [DBusInterfaceSkeletonFlags] -> m [DBusInterfaceSkeletonFlags])
-> IO [DBusInterfaceSkeletonFlags]
-> m [DBusInterfaceSkeletonFlags]
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_flags interface_'
let result' = CUInt -> [DBusInterfaceSkeletonFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
touchManagedPtr interface_
return result'
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetFlagsMethodInfo
instance (signature ~ (m [Gio.Flags.DBusInterfaceSkeletonFlags]), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetFlagsMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetFlags
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetFlags"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_info" g_dbus_interface_skeleton_get_info ::
Ptr DBusInterfaceSkeleton ->
IO (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo)
dBusInterfaceSkeletonGetInfo ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m Gio.DBusInterfaceInfo.DBusInterfaceInfo
dBusInterfaceSkeletonGetInfo :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m DBusInterfaceInfo
dBusInterfaceSkeletonGetInfo a
interface_ = IO DBusInterfaceInfo -> m DBusInterfaceInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusInterfaceInfo -> m DBusInterfaceInfo)
-> IO DBusInterfaceInfo -> m DBusInterfaceInfo
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_info interface_'
checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetInfo" result
result' <- (newBoxed Gio.DBusInterfaceInfo.DBusInterfaceInfo) result
touchManagedPtr interface_
return result'
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetInfoMethodInfo
instance (signature ~ (m Gio.DBusInterfaceInfo.DBusInterfaceInfo), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetInfoMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetInfo
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetInfoMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetInfo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetInfo"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_object_path" g_dbus_interface_skeleton_get_object_path ::
Ptr DBusInterfaceSkeleton ->
IO CString
dBusInterfaceSkeletonGetObjectPath ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m (Maybe T.Text)
dBusInterfaceSkeletonGetObjectPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m (Maybe Text)
dBusInterfaceSkeletonGetObjectPath a
interface_ = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_object_path interface_'
maybeResult <- convertIfNonNull result $ \CString
result' -> do
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
return result''
touchManagedPtr interface_
return maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetObjectPathMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetObjectPathMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetObjectPath
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetObjectPathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetObjectPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetObjectPath"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_properties" g_dbus_interface_skeleton_get_properties ::
Ptr DBusInterfaceSkeleton ->
IO (Ptr GVariant)
dBusInterfaceSkeletonGetProperties ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m GVariant
dBusInterfaceSkeletonGetProperties :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m GVariant
dBusInterfaceSkeletonGetProperties a
interface_ = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_properties interface_'
checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetProperties" result
result' <- B.GVariant.wrapGVariantPtr result
touchManagedPtr interface_
return result'
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetPropertiesMethodInfo
instance (signature ~ (m GVariant), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetPropertiesMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetProperties
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetPropertiesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetProperties",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetProperties"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_get_vtable" g_dbus_interface_skeleton_get_vtable ::
Ptr DBusInterfaceSkeleton ->
IO (Ptr Gio.DBusInterfaceVTable.DBusInterfaceVTable)
dBusInterfaceSkeletonGetVtable ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m Gio.DBusInterfaceVTable.DBusInterfaceVTable
dBusInterfaceSkeletonGetVtable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m DBusInterfaceVTable
dBusInterfaceSkeletonGetVtable a
interface_ = IO DBusInterfaceVTable -> m DBusInterfaceVTable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusInterfaceVTable -> m DBusInterfaceVTable)
-> IO DBusInterfaceVTable -> m DBusInterfaceVTable
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
result <- g_dbus_interface_skeleton_get_vtable interface_'
checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetVtable" result
result' <- (newPtr Gio.DBusInterfaceVTable.DBusInterfaceVTable) result
touchManagedPtr interface_
return result'
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonGetVtableMethodInfo
instance (signature ~ (m Gio.DBusInterfaceVTable.DBusInterfaceVTable), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonGetVtableMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonGetVtable
instance O.OverloadedMethodInfo DBusInterfaceSkeletonGetVtableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonGetVtable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonGetVtable"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_has_connection" g_dbus_interface_skeleton_has_connection ::
Ptr DBusInterfaceSkeleton ->
Ptr Gio.DBusConnection.DBusConnection ->
IO CInt
dBusInterfaceSkeletonHasConnection ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) =>
a
-> b
-> m Bool
dBusInterfaceSkeletonHasConnection :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a,
IsDBusConnection b) =>
a -> b -> m Bool
dBusInterfaceSkeletonHasConnection a
interface_ b
connection = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
connection' <- unsafeManagedPtrCastPtr connection
result <- g_dbus_interface_skeleton_has_connection interface_' connection'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr interface_
touchManagedPtr connection
return result'
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonHasConnectionMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.OverloadedMethod DBusInterfaceSkeletonHasConnectionMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonHasConnection
instance O.OverloadedMethodInfo DBusInterfaceSkeletonHasConnectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonHasConnection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonHasConnection"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_set_flags" g_dbus_interface_skeleton_set_flags ::
Ptr DBusInterfaceSkeleton ->
CUInt ->
IO ()
dBusInterfaceSkeletonSetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> [Gio.Flags.DBusInterfaceSkeletonFlags]
-> m ()
dBusInterfaceSkeletonSetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> [DBusInterfaceSkeletonFlags] -> m ()
dBusInterfaceSkeletonSetFlags a
interface_ [DBusInterfaceSkeletonFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
let flags' = [DBusInterfaceSkeletonFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DBusInterfaceSkeletonFlags]
flags
g_dbus_interface_skeleton_set_flags interface_' flags'
touchManagedPtr interface_
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonSetFlagsMethodInfo
instance (signature ~ ([Gio.Flags.DBusInterfaceSkeletonFlags] -> m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonSetFlagsMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonSetFlags
instance O.OverloadedMethodInfo DBusInterfaceSkeletonSetFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonSetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonSetFlags"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_unexport" g_dbus_interface_skeleton_unexport ::
Ptr DBusInterfaceSkeleton ->
IO ()
dBusInterfaceSkeletonUnexport ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a
-> m ()
dBusInterfaceSkeletonUnexport :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
a -> m ()
dBusInterfaceSkeletonUnexport a
interface_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
g_dbus_interface_skeleton_unexport interface_'
touchManagedPtr interface_
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonUnexportMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.OverloadedMethod DBusInterfaceSkeletonUnexportMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonUnexport
instance O.OverloadedMethodInfo DBusInterfaceSkeletonUnexportMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexport",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonUnexport"
})
#endif
foreign import ccall "g_dbus_interface_skeleton_unexport_from_connection" g_dbus_interface_skeleton_unexport_from_connection ::
Ptr DBusInterfaceSkeleton ->
Ptr Gio.DBusConnection.DBusConnection ->
IO ()
dBusInterfaceSkeletonUnexportFromConnection ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) =>
a
-> b
-> m ()
dBusInterfaceSkeletonUnexportFromConnection :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a,
IsDBusConnection b) =>
a -> b -> m ()
dBusInterfaceSkeletonUnexportFromConnection a
interface_ b
connection = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
interface_' <- a -> IO (Ptr DBusInterfaceSkeleton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interface_
connection' <- unsafeManagedPtrCastPtr connection
g_dbus_interface_skeleton_unexport_from_connection interface_' connection'
touchManagedPtr interface_
touchManagedPtr connection
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceSkeletonUnexportFromConnectionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.OverloadedMethod DBusInterfaceSkeletonUnexportFromConnectionMethodInfo a signature where
overloadedMethod = dBusInterfaceSkeletonUnexportFromConnection
instance O.OverloadedMethodInfo DBusInterfaceSkeletonUnexportFromConnectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexportFromConnection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DBusInterfaceSkeleton.html#v:dBusInterfaceSkeletonUnexportFromConnection"
})
#endif