{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) Abstract base class for D-Bus interfaces on the service side. /Since: 2.30/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.DBusInterfaceSkeleton ( -- * Exported types DBusInterfaceSkeleton(..) , IsDBusInterfaceSkeleton , toDBusInterfaceSkeleton , noDBusInterfaceSkeleton , -- * Methods -- ** export #method:export# #if ENABLE_OVERLOADING DBusInterfaceSkeletonExportMethodInfo , #endif dBusInterfaceSkeletonExport , -- ** flush #method:flush# #if ENABLE_OVERLOADING DBusInterfaceSkeletonFlushMethodInfo , #endif dBusInterfaceSkeletonFlush , -- ** getConnection #method:getConnection# #if ENABLE_OVERLOADING DBusInterfaceSkeletonGetConnectionMethodInfo, #endif dBusInterfaceSkeletonGetConnection , -- ** getConnections #method:getConnections# #if ENABLE_OVERLOADING DBusInterfaceSkeletonGetConnectionsMethodInfo, #endif dBusInterfaceSkeletonGetConnections , -- ** getFlags #method:getFlags# #if ENABLE_OVERLOADING DBusInterfaceSkeletonGetFlagsMethodInfo , #endif dBusInterfaceSkeletonGetFlags , -- ** getInfo #method:getInfo# #if ENABLE_OVERLOADING DBusInterfaceSkeletonGetInfoMethodInfo , #endif dBusInterfaceSkeletonGetInfo , -- ** getObjectPath #method:getObjectPath# #if ENABLE_OVERLOADING DBusInterfaceSkeletonGetObjectPathMethodInfo, #endif dBusInterfaceSkeletonGetObjectPath , -- ** getProperties #method:getProperties# #if ENABLE_OVERLOADING DBusInterfaceSkeletonGetPropertiesMethodInfo, #endif dBusInterfaceSkeletonGetProperties , -- ** hasConnection #method:hasConnection# #if ENABLE_OVERLOADING DBusInterfaceSkeletonHasConnectionMethodInfo, #endif dBusInterfaceSkeletonHasConnection , -- ** setFlags #method:setFlags# #if ENABLE_OVERLOADING DBusInterfaceSkeletonSetFlagsMethodInfo , #endif dBusInterfaceSkeletonSetFlags , -- ** unexport #method:unexport# #if ENABLE_OVERLOADING DBusInterfaceSkeletonUnexportMethodInfo , #endif dBusInterfaceSkeletonUnexport , -- ** unexportFromConnection #method:unexportFromConnection# #if ENABLE_OVERLOADING DBusInterfaceSkeletonUnexportFromConnectionMethodInfo, #endif dBusInterfaceSkeletonUnexportFromConnection, -- * Properties -- ** gFlags #attr:gFlags# {- | Flags from the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' enumeration. /Since: 2.30/ -} #if ENABLE_OVERLOADING DBusInterfaceSkeletonGFlagsPropertyInfo , #endif constructDBusInterfaceSkeletonGFlags , #if ENABLE_OVERLOADING dBusInterfaceSkeletonGFlags , #endif getDBusInterfaceSkeletonGFlags , setDBusInterfaceSkeletonGFlags , -- * Signals -- ** gAuthorizeMethod #signal:gAuthorizeMethod# C_DBusInterfaceSkeletonGAuthorizeMethodCallback, DBusInterfaceSkeletonGAuthorizeMethodCallback, #if ENABLE_OVERLOADING DBusInterfaceSkeletonGAuthorizeMethodSignalInfo, #endif afterDBusInterfaceSkeletonGAuthorizeMethod, genClosure_DBusInterfaceSkeletonGAuthorizeMethod, mk_DBusInterfaceSkeletonGAuthorizeMethodCallback, noDBusInterfaceSkeletonGAuthorizeMethodCallback, onDBusInterfaceSkeletonGAuthorizeMethod , wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback, ) 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.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.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 -- | Memory-managed wrapper type. newtype DBusInterfaceSkeleton = DBusInterfaceSkeleton (ManagedPtr DBusInterfaceSkeleton) foreign import ccall "g_dbus_interface_skeleton_get_type" c_g_dbus_interface_skeleton_get_type :: IO GType instance GObject DBusInterfaceSkeleton where gobjectType = c_g_dbus_interface_skeleton_get_type -- | Type class for types which can be safely cast to `DBusInterfaceSkeleton`, for instance with `toDBusInterfaceSkeleton`. class (GObject o, O.IsDescendantOf DBusInterfaceSkeleton o) => IsDBusInterfaceSkeleton o instance (GObject o, O.IsDescendantOf DBusInterfaceSkeleton o) => IsDBusInterfaceSkeleton o instance O.HasParentTypes DBusInterfaceSkeleton type instance O.ParentTypes DBusInterfaceSkeleton = '[GObject.Object.Object, Gio.DBusInterface.DBusInterface] -- | Cast to `DBusInterfaceSkeleton`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toDBusInterfaceSkeleton :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> m DBusInterfaceSkeleton toDBusInterfaceSkeleton = liftIO . unsafeCastTo DBusInterfaceSkeleton -- | A convenience alias for `Nothing` :: `Maybe` `DBusInterfaceSkeleton`. noDBusInterfaceSkeleton :: Maybe DBusInterfaceSkeleton noDBusInterfaceSkeleton = Nothing #if ENABLE_OVERLOADING type family ResolveDBusInterfaceSkeletonMethod (t :: Symbol) (o :: *) :: * 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 "setData" o = GObject.Object.ObjectSetDataMethodInfo 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.MethodInfo info DBusInterfaceSkeleton p) => OL.IsLabel t (DBusInterfaceSkeleton -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal DBusInterfaceSkeleton::g-authorize-method {- | Emitted when a method is invoked by a remote caller and used to determine if the method call is authorized. Note that this signal is emitted in a thread dedicated to handling the method call so handlers are allowed to perform blocking IO. This means that it is appropriate to call e.g. with the flag set. If 'False' is returned then no further handlers are run and the signal handler must take a reference to /@invocation@/ and finish handling the call (e.g. return an error via @/g_dbus_method_invocation_return_error()/@). Otherwise, if 'True' is returned, signal emission continues. If no handlers return 'False', then the method is dispatched. If /@interface@/ has an enclosing 'GI.Gio.Objects.DBusObjectSkeleton.DBusObjectSkeleton', then the 'GI.Gio.Objects.DBusObjectSkeleton.DBusObjectSkeleton'::@/authorize-method/@ signal handlers run before the handlers for this signal. The default class handler just returns 'True'. Please note that the common case is optimized: if no signals handlers are connected and the default class handler isn\'t overridden (for both /@interface@/ and the enclosing 'GI.Gio.Objects.DBusObjectSkeleton.DBusObjectSkeleton', if any) and 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton':@/g-flags/@ does not have the 'GI.Gio.Flags.DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread' flags set, no dedicated thread is ever used and the call will be handled in the same thread as the object that /@interface@/ belongs to was exported in. /Since: 2.30/ -} type DBusInterfaceSkeletonGAuthorizeMethodCallback = Gio.DBusMethodInvocation.DBusMethodInvocation {- ^ /@invocation@/: A 'GI.Gio.Objects.DBusMethodInvocation.DBusMethodInvocation'. -} -> IO Bool {- ^ __Returns:__ 'True' if the call is authorized, 'False' otherwise. -} -- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceSkeletonGAuthorizeMethodCallback`@. noDBusInterfaceSkeletonGAuthorizeMethodCallback :: Maybe DBusInterfaceSkeletonGAuthorizeMethodCallback noDBusInterfaceSkeletonGAuthorizeMethodCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_DBusInterfaceSkeletonGAuthorizeMethodCallback = Ptr () -> -- object Ptr Gio.DBusMethodInvocation.DBusMethodInvocation -> Ptr () -> -- user_data IO CInt -- | Generate a function pointer callable from C code, from a `C_DBusInterfaceSkeletonGAuthorizeMethodCallback`. foreign import ccall "wrapper" mk_DBusInterfaceSkeletonGAuthorizeMethodCallback :: C_DBusInterfaceSkeletonGAuthorizeMethodCallback -> IO (FunPtr C_DBusInterfaceSkeletonGAuthorizeMethodCallback) -- | Wrap the callback into a `GClosure`. genClosure_DBusInterfaceSkeletonGAuthorizeMethod :: MonadIO m => DBusInterfaceSkeletonGAuthorizeMethodCallback -> m (GClosure C_DBusInterfaceSkeletonGAuthorizeMethodCallback) genClosure_DBusInterfaceSkeletonGAuthorizeMethod cb = liftIO $ do let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `DBusInterfaceSkeletonGAuthorizeMethodCallback` into a `C_DBusInterfaceSkeletonGAuthorizeMethodCallback`. wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback :: DBusInterfaceSkeletonGAuthorizeMethodCallback -> C_DBusInterfaceSkeletonGAuthorizeMethodCallback wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback _cb _ invocation _ = do invocation' <- (newObject Gio.DBusMethodInvocation.DBusMethodInvocation) invocation result <- _cb invocation' let result' = (fromIntegral . fromEnum) result return result' {- | Connect a signal handler for the “@g-authorize-method@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' dBusInterfaceSkeleton #gAuthorizeMethod callback @ -} onDBusInterfaceSkeletonGAuthorizeMethod :: (IsDBusInterfaceSkeleton a, MonadIO m) => a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> m SignalHandlerId onDBusInterfaceSkeletonGAuthorizeMethod obj cb = liftIO $ do let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb' connectSignalFunPtr obj "g-authorize-method" cb'' SignalConnectBefore {- | Connect a signal handler for the “@g-authorize-method@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' dBusInterfaceSkeleton #gAuthorizeMethod callback @ -} afterDBusInterfaceSkeletonGAuthorizeMethod :: (IsDBusInterfaceSkeleton a, MonadIO m) => a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> m SignalHandlerId afterDBusInterfaceSkeletonGAuthorizeMethod obj cb = liftIO $ do let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb' connectSignalFunPtr obj "g-authorize-method" cb'' SignalConnectAfter -- VVV Prop "g-flags" -- Type: TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeletonFlags"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@g-flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusInterfaceSkeleton #gFlags @ -} getDBusInterfaceSkeletonGFlags :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> m [Gio.Flags.DBusInterfaceSkeletonFlags] getDBusInterfaceSkeletonGFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "g-flags" {- | Set the value of the “@g-flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' dBusInterfaceSkeleton [ #gFlags 'Data.GI.Base.Attributes.:=' value ] @ -} setDBusInterfaceSkeletonGFlags :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> [Gio.Flags.DBusInterfaceSkeletonFlags] -> m () setDBusInterfaceSkeletonGFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "g-flags" val {- | Construct a `GValueConstruct` with valid value for the “@g-flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructDBusInterfaceSkeletonGFlags :: (IsDBusInterfaceSkeleton o) => [Gio.Flags.DBusInterfaceSkeletonFlags] -> IO (GValueConstruct o) constructDBusInterfaceSkeletonGFlags val = B.Properties.constructObjectPropertyFlags "g-flags" val #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGFlagsPropertyInfo instance AttrInfo DBusInterfaceSkeletonGFlagsPropertyInfo where type AttrAllowedOps DBusInterfaceSkeletonGFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = (~) [Gio.Flags.DBusInterfaceSkeletonFlags] type AttrBaseTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = IsDBusInterfaceSkeleton type AttrGetType DBusInterfaceSkeletonGFlagsPropertyInfo = [Gio.Flags.DBusInterfaceSkeletonFlags] type AttrLabel DBusInterfaceSkeletonGFlagsPropertyInfo = "g-flags" type AttrOrigin DBusInterfaceSkeletonGFlagsPropertyInfo = DBusInterfaceSkeleton attrGet _ = getDBusInterfaceSkeletonGFlags attrSet _ = setDBusInterfaceSkeletonGFlags attrConstruct _ = constructDBusInterfaceSkeletonGFlags attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList DBusInterfaceSkeleton type instance O.AttributeList DBusInterfaceSkeleton = DBusInterfaceSkeletonAttributeList type DBusInterfaceSkeletonAttributeList = ('[ '("gFlags", DBusInterfaceSkeletonGFlagsPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING dBusInterfaceSkeletonGFlags :: AttrLabelProxy "gFlags" dBusInterfaceSkeletonGFlags = AttrLabelProxy #endif #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGAuthorizeMethodSignalInfo instance SignalInfo DBusInterfaceSkeletonGAuthorizeMethodSignalInfo where type HaskellCallbackType DBusInterfaceSkeletonGAuthorizeMethodSignalInfo = DBusInterfaceSkeletonGAuthorizeMethodCallback connectSignal _ obj cb connectMode = do let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb' connectSignalFunPtr obj "g-authorize-method" cb'' connectMode type instance O.SignalList DBusInterfaceSkeleton = DBusInterfaceSkeletonSignalList type DBusInterfaceSkeletonSignalList = ('[ '("gAuthorizeMethod", DBusInterfaceSkeletonGAuthorizeMethodSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method DBusInterfaceSkeleton::export -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The D-Bus interface to export.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusConnection to export @interface_ on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The path to export the interface at.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : True -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_export" g_dbus_interface_skeleton_export :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"}) CString -> -- object_path : TBasicType TUTF8 Ptr (Ptr GError) -> -- error IO CInt {- | Exports /@interface_@/ at /@objectPath@/ on /@connection@/. This can be called multiple times to export the same /@interface_@/ onto multiple connections however the /@objectPath@/ provided must be the same for all connections. Use 'GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexport' to unexport the object. /Since: 2.30/ -} dBusInterfaceSkeletonExport :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => a {- ^ /@interface_@/: The D-Bus interface to export. -} -> b {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection' to export /@interface_@/ on. -} -> T.Text {- ^ /@objectPath@/: The path to export the interface at. -} -> m () {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusInterfaceSkeletonExport interface_ connection objectPath = liftIO $ do interface_' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING data DBusInterfaceSkeletonExportMethodInfo instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.MethodInfo DBusInterfaceSkeletonExportMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonExport #endif -- method DBusInterfaceSkeleton::flush -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_flush" g_dbus_interface_skeleton_flush :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO () {- | If /@interface_@/ has outstanding changes, request for these changes to be emitted immediately. For example, an exported D-Bus interface may queue up property changes and emit the @org.freedesktop.DBus.Properties.PropertiesChanged@ signal later (e.g. in an idle handler). This technique is useful for collapsing multiple property changes into one. /Since: 2.30/ -} dBusInterfaceSkeletonFlush :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m () dBusInterfaceSkeletonFlush interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ g_dbus_interface_skeleton_flush interface_' touchManagedPtr interface_ return () #if ENABLE_OVERLOADING data DBusInterfaceSkeletonFlushMethodInfo instance (signature ~ (m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonFlushMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonFlush #endif -- method DBusInterfaceSkeleton::get_connection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusConnection"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_get_connection" g_dbus_interface_skeleton_get_connection :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO (Ptr Gio.DBusConnection.DBusConnection) {- | Gets the first connection that /@interface_@/ is exported on, if any. /Since: 2.30/ -} dBusInterfaceSkeletonGetConnection :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m Gio.DBusConnection.DBusConnection {- ^ __Returns:__ A 'GI.Gio.Objects.DBusConnection.DBusConnection' or 'Nothing' if /@interface_@/ is not exported anywhere. Do not free, the object belongs to /@interface_@/. -} dBusInterfaceSkeletonGetConnection interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ result <- g_dbus_interface_skeleton_get_connection interface_' checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetConnection" result result' <- (newObject Gio.DBusConnection.DBusConnection) result touchManagedPtr interface_ return result' #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGetConnectionMethodInfo instance (signature ~ (m Gio.DBusConnection.DBusConnection), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetConnectionMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonGetConnection #endif -- method DBusInterfaceSkeleton::get_connections -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "DBusConnection"}))) -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_get_connections" g_dbus_interface_skeleton_get_connections :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO (Ptr (GList (Ptr Gio.DBusConnection.DBusConnection))) {- | Gets a list of the connections that /@interface_@/ is exported on. /Since: 2.32/ -} dBusInterfaceSkeletonGetConnections :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m [Gio.DBusConnection.DBusConnection] {- ^ __Returns:__ A list of all the connections that /@interface_@/ is exported on. The returned list should be freed with @/g_list_free()/@ after each element has been freed with 'GI.GObject.Objects.Object.objectUnref'. -} dBusInterfaceSkeletonGetConnections interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING data DBusInterfaceSkeletonGetConnectionsMethodInfo instance (signature ~ (m [Gio.DBusConnection.DBusConnection]), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetConnectionsMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonGetConnections #endif -- method DBusInterfaceSkeleton::get_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeletonFlags"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_get_flags" g_dbus_interface_skeleton_get_flags :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO CUInt {- | Gets the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' that describes what the behavior of /@interface_@/ /Since: 2.30/ -} dBusInterfaceSkeletonGetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m [Gio.Flags.DBusInterfaceSkeletonFlags] {- ^ __Returns:__ One or more flags from the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' enumeration. -} dBusInterfaceSkeletonGetFlags interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ result <- g_dbus_interface_skeleton_get_flags interface_' let result' = wordToGFlags result touchManagedPtr interface_ return result' #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGetFlagsMethodInfo instance (signature ~ (m [Gio.Flags.DBusInterfaceSkeletonFlags]), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetFlagsMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonGetFlags #endif -- method DBusInterfaceSkeleton::get_info -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusInterfaceInfo"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_get_info" g_dbus_interface_skeleton_get_info :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo) {- | Gets D-Bus introspection information for the D-Bus interface implemented by /@interface_@/. /Since: 2.30/ -} dBusInterfaceSkeletonGetInfo :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m Gio.DBusInterfaceInfo.DBusInterfaceInfo {- ^ __Returns:__ A 'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo' (never 'Nothing'). Do not free. -} dBusInterfaceSkeletonGetInfo interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ result <- g_dbus_interface_skeleton_get_info interface_' checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetInfo" result result' <- (newBoxed Gio.DBusInterfaceInfo.DBusInterfaceInfo) result touchManagedPtr interface_ return result' #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGetInfoMethodInfo instance (signature ~ (m Gio.DBusInterfaceInfo.DBusInterfaceInfo), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetInfoMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonGetInfo #endif -- method DBusInterfaceSkeleton::get_object_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_get_object_path" g_dbus_interface_skeleton_get_object_path :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO CString {- | Gets the object path that /@interface_@/ is exported on, if any. /Since: 2.30/ -} dBusInterfaceSkeletonGetObjectPath :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m T.Text {- ^ __Returns:__ A string owned by /@interface_@/ or 'Nothing' if /@interface_@/ is not exported anywhere. Do not free, the string belongs to /@interface_@/. -} dBusInterfaceSkeletonGetObjectPath interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ result <- g_dbus_interface_skeleton_get_object_path interface_' checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetObjectPath" result result' <- cstringToText result touchManagedPtr interface_ return result' #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGetObjectPathMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetObjectPathMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonGetObjectPath #endif -- method DBusInterfaceSkeleton::get_properties -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just TVariant -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_get_properties" g_dbus_interface_skeleton_get_properties :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO (Ptr GVariant) {- | Gets all D-Bus properties for /@interface_@/. /Since: 2.30/ -} dBusInterfaceSkeletonGetProperties :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m GVariant {- ^ __Returns:__ A 'GVariant' of type [\'a{sv}\'][G-VARIANT-TYPE-VARDICT:CAPS]. Free with 'GI.GLib.Structs.Variant.variantUnref'. -} dBusInterfaceSkeletonGetProperties interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ result <- g_dbus_interface_skeleton_get_properties interface_' checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetProperties" result result' <- B.GVariant.wrapGVariantPtr result touchManagedPtr interface_ return result' #if ENABLE_OVERLOADING data DBusInterfaceSkeletonGetPropertiesMethodInfo instance (signature ~ (m GVariant), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetPropertiesMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonGetProperties #endif -- method DBusInterfaceSkeleton::has_connection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusConnection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_has_connection" g_dbus_interface_skeleton_has_connection :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"}) IO CInt {- | Checks if /@interface_@/ is exported on /@connection@/. /Since: 2.32/ -} dBusInterfaceSkeletonHasConnection :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> b {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection'. -} -> m Bool {- ^ __Returns:__ 'True' if /@interface_@/ is exported on /@connection@/, 'False' otherwise. -} dBusInterfaceSkeletonHasConnection interface_ connection = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ connection' <- unsafeManagedPtrCastPtr connection result <- g_dbus_interface_skeleton_has_connection interface_' connection' let result' = (/= 0) result touchManagedPtr interface_ touchManagedPtr connection return result' #if ENABLE_OVERLOADING data DBusInterfaceSkeletonHasConnectionMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.MethodInfo DBusInterfaceSkeletonHasConnectionMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonHasConnection #endif -- method DBusInterfaceSkeleton::set_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeletonFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags from the #GDBusInterfaceSkeletonFlags enumeration.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_set_flags" g_dbus_interface_skeleton_set_flags :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) CUInt -> -- flags : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeletonFlags"}) IO () {- | Sets flags describing what the behavior of /@skeleton@/ should be. /Since: 2.30/ -} dBusInterfaceSkeletonSetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> [Gio.Flags.DBusInterfaceSkeletonFlags] {- ^ /@flags@/: Flags from the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' enumeration. -} -> m () dBusInterfaceSkeletonSetFlags interface_ flags = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ let flags' = gflagsToWord flags g_dbus_interface_skeleton_set_flags interface_' flags' touchManagedPtr interface_ return () #if ENABLE_OVERLOADING data DBusInterfaceSkeletonSetFlagsMethodInfo instance (signature ~ ([Gio.Flags.DBusInterfaceSkeletonFlags] -> m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonSetFlagsMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonSetFlags #endif -- method DBusInterfaceSkeleton::unexport -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_unexport" g_dbus_interface_skeleton_unexport :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) IO () {- | Stops exporting /@interface_@/ on all connections it is exported on. To unexport /@interface_@/ from only a single connection, use 'GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexportFromConnection' /Since: 2.30/ -} dBusInterfaceSkeletonUnexport :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> m () dBusInterfaceSkeletonUnexport interface_ = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ g_dbus_interface_skeleton_unexport interface_' touchManagedPtr interface_ return () #if ENABLE_OVERLOADING data DBusInterfaceSkeletonUnexportMethodInfo instance (signature ~ (m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonUnexportMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonUnexport #endif -- method DBusInterfaceSkeleton::unexport_from_connection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusConnection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_interface_skeleton_unexport_from_connection" g_dbus_interface_skeleton_unexport_from_connection :: Ptr DBusInterfaceSkeleton -> -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}) Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"}) IO () {- | Stops exporting /@interface_@/ on /@connection@/. To stop exporting on all connections the interface is exported on, use 'GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexport'. /Since: 2.32/ -} dBusInterfaceSkeletonUnexportFromConnection :: (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => a {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -} -> b {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection'. -} -> m () dBusInterfaceSkeletonUnexportFromConnection interface_ connection = liftIO $ do interface_' <- unsafeManagedPtrCastPtr interface_ connection' <- unsafeManagedPtrCastPtr connection g_dbus_interface_skeleton_unexport_from_connection interface_' connection' touchManagedPtr interface_ touchManagedPtr connection return () #if ENABLE_OVERLOADING data DBusInterfaceSkeletonUnexportFromConnectionMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.MethodInfo DBusInterfaceSkeletonUnexportFromConnectionMethodInfo a signature where overloadedMethod _ = dBusInterfaceSkeletonUnexportFromConnection #endif