{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Gio.Objects.DBusServer.DBusServer' is a helper for listening to and accepting D-Bus connections. This can be used to create a new D-Bus server, allowing two peers to use the D-Bus protocol for their own specialized communication. A server instance provided in this way will not perform message routing or implement the org.freedesktop.DBus interface. To just export an object on a well-known name on a message bus, such as the session or system bus, you should instead use @/g_bus_own_name()/@. An example of peer-to-peer communication with G-DBus can be found in . /Since: 2.26/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.DBusServer ( -- * Exported types DBusServer(..) , IsDBusServer , toDBusServer , noDBusServer , -- * Methods -- ** getClientAddress #method:getClientAddress# #if ENABLE_OVERLOADING DBusServerGetClientAddressMethodInfo , #endif dBusServerGetClientAddress , -- ** getFlags #method:getFlags# #if ENABLE_OVERLOADING DBusServerGetFlagsMethodInfo , #endif dBusServerGetFlags , -- ** getGuid #method:getGuid# #if ENABLE_OVERLOADING DBusServerGetGuidMethodInfo , #endif dBusServerGetGuid , -- ** isActive #method:isActive# #if ENABLE_OVERLOADING DBusServerIsActiveMethodInfo , #endif dBusServerIsActive , -- ** newSync #method:newSync# dBusServerNewSync , -- ** start #method:start# #if ENABLE_OVERLOADING DBusServerStartMethodInfo , #endif dBusServerStart , -- ** stop #method:stop# #if ENABLE_OVERLOADING DBusServerStopMethodInfo , #endif dBusServerStop , -- * Properties -- ** active #attr:active# {- | Whether the server is currently active. /Since: 2.26/ -} #if ENABLE_OVERLOADING DBusServerActivePropertyInfo , #endif #if ENABLE_OVERLOADING dBusServerActive , #endif getDBusServerActive , -- ** address #attr:address# {- | The D-Bus address to listen on. /Since: 2.26/ -} #if ENABLE_OVERLOADING DBusServerAddressPropertyInfo , #endif constructDBusServerAddress , #if ENABLE_OVERLOADING dBusServerAddress , #endif getDBusServerAddress , -- ** authenticationObserver #attr:authenticationObserver# {- | A 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' object to assist in the authentication process or 'Nothing'. /Since: 2.26/ -} #if ENABLE_OVERLOADING DBusServerAuthenticationObserverPropertyInfo, #endif constructDBusServerAuthenticationObserver, #if ENABLE_OVERLOADING dBusServerAuthenticationObserver , #endif getDBusServerAuthenticationObserver , -- ** clientAddress #attr:clientAddress# {- | The D-Bus address that clients can use. /Since: 2.26/ -} #if ENABLE_OVERLOADING DBusServerClientAddressPropertyInfo , #endif #if ENABLE_OVERLOADING dBusServerClientAddress , #endif getDBusServerClientAddress , -- ** flags #attr:flags# {- | Flags from the 'GI.Gio.Flags.DBusServerFlags' enumeration. /Since: 2.26/ -} #if ENABLE_OVERLOADING DBusServerFlagsPropertyInfo , #endif constructDBusServerFlags , #if ENABLE_OVERLOADING dBusServerFlags , #endif getDBusServerFlags , -- ** guid #attr:guid# {- | The guid of the server. /Since: 2.26/ -} #if ENABLE_OVERLOADING DBusServerGuidPropertyInfo , #endif constructDBusServerGuid , #if ENABLE_OVERLOADING dBusServerGuid , #endif getDBusServerGuid , -- * Signals -- ** newConnection #signal:newConnection# C_DBusServerNewConnectionCallback , DBusServerNewConnectionCallback , #if ENABLE_OVERLOADING DBusServerNewConnectionSignalInfo , #endif afterDBusServerNewConnection , genClosure_DBusServerNewConnection , mk_DBusServerNewConnectionCallback , noDBusServerNewConnectionCallback , onDBusServerNewConnection , wrap_DBusServerNewConnectionCallback , ) 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.Initable as Gio.Initable import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable import {-# SOURCE #-} qualified GI.Gio.Objects.DBusAuthObserver as Gio.DBusAuthObserver import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection -- | Memory-managed wrapper type. newtype DBusServer = DBusServer (ManagedPtr DBusServer) foreign import ccall "g_dbus_server_get_type" c_g_dbus_server_get_type :: IO GType instance GObject DBusServer where gobjectType = c_g_dbus_server_get_type -- | Type class for types which can be safely cast to `DBusServer`, for instance with `toDBusServer`. class (GObject o, O.IsDescendantOf DBusServer o) => IsDBusServer o instance (GObject o, O.IsDescendantOf DBusServer o) => IsDBusServer o instance O.HasParentTypes DBusServer type instance O.ParentTypes DBusServer = '[GObject.Object.Object, Gio.Initable.Initable] -- | Cast to `DBusServer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toDBusServer :: (MonadIO m, IsDBusServer o) => o -> m DBusServer toDBusServer = liftIO . unsafeCastTo DBusServer -- | A convenience alias for `Nothing` :: `Maybe` `DBusServer`. noDBusServer :: Maybe DBusServer noDBusServer = Nothing #if ENABLE_OVERLOADING type family ResolveDBusServerMethod (t :: Symbol) (o :: *) :: * where ResolveDBusServerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveDBusServerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveDBusServerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveDBusServerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveDBusServerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveDBusServerMethod "init" o = Gio.Initable.InitableInitMethodInfo ResolveDBusServerMethod "isActive" o = DBusServerIsActiveMethodInfo ResolveDBusServerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveDBusServerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveDBusServerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveDBusServerMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveDBusServerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveDBusServerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveDBusServerMethod "start" o = DBusServerStartMethodInfo ResolveDBusServerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveDBusServerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveDBusServerMethod "stop" o = DBusServerStopMethodInfo ResolveDBusServerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveDBusServerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveDBusServerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveDBusServerMethod "getClientAddress" o = DBusServerGetClientAddressMethodInfo ResolveDBusServerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveDBusServerMethod "getFlags" o = DBusServerGetFlagsMethodInfo ResolveDBusServerMethod "getGuid" o = DBusServerGetGuidMethodInfo ResolveDBusServerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveDBusServerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveDBusServerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveDBusServerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveDBusServerMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveDBusServerMethod t DBusServer, O.MethodInfo info DBusServer p) => OL.IsLabel t (DBusServer -> 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 DBusServer::new-connection {- | Emitted when a new authenticated connection has been made. Use 'GI.Gio.Objects.DBusConnection.dBusConnectionGetPeerCredentials' to figure out what identity (if any), was authenticated. If you want to accept the connection, take a reference to the /@connection@/ object and return 'True'. When you are done with the connection call 'GI.Gio.Objects.DBusConnection.dBusConnectionClose' and give up your reference. Note that the other peer may disconnect at any time - a typical thing to do when accepting a connection is to listen to the 'GI.Gio.Objects.DBusConnection.DBusConnection'::@/closed/@ signal. If 'GI.Gio.Objects.DBusServer.DBusServer':@/flags/@ contains 'GI.Gio.Flags.DBusServerFlagsRunInThread' then the signal is emitted in a new thread dedicated to the connection. Otherwise the signal is emitted in the [thread-default main context][g-main-context-push-thread-default] of the thread that /@server@/ was constructed in. You are guaranteed that signal handlers for this signal runs before incoming messages on /@connection@/ are processed. This means that it\'s suitable to call @/g_dbus_connection_register_object()/@ or similar from the signal handler. /Since: 2.26/ -} type DBusServerNewConnectionCallback = Gio.DBusConnection.DBusConnection {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection' for the new connection. -} -> IO Bool {- ^ __Returns:__ 'True' to claim /@connection@/, 'False' to let other handlers run. -} -- | A convenience synonym for @`Nothing` :: `Maybe` `DBusServerNewConnectionCallback`@. noDBusServerNewConnectionCallback :: Maybe DBusServerNewConnectionCallback noDBusServerNewConnectionCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_DBusServerNewConnectionCallback = Ptr () -> -- object Ptr Gio.DBusConnection.DBusConnection -> Ptr () -> -- user_data IO CInt -- | Generate a function pointer callable from C code, from a `C_DBusServerNewConnectionCallback`. foreign import ccall "wrapper" mk_DBusServerNewConnectionCallback :: C_DBusServerNewConnectionCallback -> IO (FunPtr C_DBusServerNewConnectionCallback) -- | Wrap the callback into a `GClosure`. genClosure_DBusServerNewConnection :: MonadIO m => DBusServerNewConnectionCallback -> m (GClosure C_DBusServerNewConnectionCallback) genClosure_DBusServerNewConnection cb = liftIO $ do let cb' = wrap_DBusServerNewConnectionCallback cb mk_DBusServerNewConnectionCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `DBusServerNewConnectionCallback` into a `C_DBusServerNewConnectionCallback`. wrap_DBusServerNewConnectionCallback :: DBusServerNewConnectionCallback -> C_DBusServerNewConnectionCallback wrap_DBusServerNewConnectionCallback _cb _ connection _ = do connection' <- (newObject Gio.DBusConnection.DBusConnection) connection result <- _cb connection' let result' = (fromIntegral . fromEnum) result return result' {- | Connect a signal handler for the “@new-connection@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' dBusServer #newConnection callback @ -} onDBusServerNewConnection :: (IsDBusServer a, MonadIO m) => a -> DBusServerNewConnectionCallback -> m SignalHandlerId onDBusServerNewConnection obj cb = liftIO $ do let cb' = wrap_DBusServerNewConnectionCallback cb cb'' <- mk_DBusServerNewConnectionCallback cb' connectSignalFunPtr obj "new-connection" cb'' SignalConnectBefore {- | Connect a signal handler for the “@new-connection@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' dBusServer #newConnection callback @ -} afterDBusServerNewConnection :: (IsDBusServer a, MonadIO m) => a -> DBusServerNewConnectionCallback -> m SignalHandlerId afterDBusServerNewConnection obj cb = liftIO $ do let cb' = wrap_DBusServerNewConnectionCallback cb cb'' <- mk_DBusServerNewConnectionCallback cb' connectSignalFunPtr obj "new-connection" cb'' SignalConnectAfter -- VVV Prop "active" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@active@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusServer #active @ -} getDBusServerActive :: (MonadIO m, IsDBusServer o) => o -> m Bool getDBusServerActive obj = liftIO $ B.Properties.getObjectPropertyBool obj "active" #if ENABLE_OVERLOADING data DBusServerActivePropertyInfo instance AttrInfo DBusServerActivePropertyInfo where type AttrAllowedOps DBusServerActivePropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint DBusServerActivePropertyInfo = (~) () type AttrBaseTypeConstraint DBusServerActivePropertyInfo = IsDBusServer type AttrGetType DBusServerActivePropertyInfo = Bool type AttrLabel DBusServerActivePropertyInfo = "active" type AttrOrigin DBusServerActivePropertyInfo = DBusServer attrGet _ = getDBusServerActive attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "address" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@address@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusServer #address @ -} getDBusServerAddress :: (MonadIO m, IsDBusServer o) => o -> m (Maybe T.Text) getDBusServerAddress obj = liftIO $ B.Properties.getObjectPropertyString obj "address" {- | Construct a `GValueConstruct` with valid value for the “@address@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructDBusServerAddress :: (IsDBusServer o) => T.Text -> IO (GValueConstruct o) constructDBusServerAddress val = B.Properties.constructObjectPropertyString "address" (Just val) #if ENABLE_OVERLOADING data DBusServerAddressPropertyInfo instance AttrInfo DBusServerAddressPropertyInfo where type AttrAllowedOps DBusServerAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint DBusServerAddressPropertyInfo = (~) T.Text type AttrBaseTypeConstraint DBusServerAddressPropertyInfo = IsDBusServer type AttrGetType DBusServerAddressPropertyInfo = (Maybe T.Text) type AttrLabel DBusServerAddressPropertyInfo = "address" type AttrOrigin DBusServerAddressPropertyInfo = DBusServer attrGet _ = getDBusServerAddress attrSet _ = undefined attrConstruct _ = constructDBusServerAddress attrClear _ = undefined #endif -- VVV Prop "authentication-observer" -- Type: TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@authentication-observer@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusServer #authenticationObserver @ -} getDBusServerAuthenticationObserver :: (MonadIO m, IsDBusServer o) => o -> m (Maybe Gio.DBusAuthObserver.DBusAuthObserver) getDBusServerAuthenticationObserver obj = liftIO $ B.Properties.getObjectPropertyObject obj "authentication-observer" Gio.DBusAuthObserver.DBusAuthObserver {- | Construct a `GValueConstruct` with valid value for the “@authentication-observer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructDBusServerAuthenticationObserver :: (IsDBusServer o, Gio.DBusAuthObserver.IsDBusAuthObserver a) => a -> IO (GValueConstruct o) constructDBusServerAuthenticationObserver val = B.Properties.constructObjectPropertyObject "authentication-observer" (Just val) #if ENABLE_OVERLOADING data DBusServerAuthenticationObserverPropertyInfo instance AttrInfo DBusServerAuthenticationObserverPropertyInfo where type AttrAllowedOps DBusServerAuthenticationObserverPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint DBusServerAuthenticationObserverPropertyInfo = Gio.DBusAuthObserver.IsDBusAuthObserver type AttrBaseTypeConstraint DBusServerAuthenticationObserverPropertyInfo = IsDBusServer type AttrGetType DBusServerAuthenticationObserverPropertyInfo = (Maybe Gio.DBusAuthObserver.DBusAuthObserver) type AttrLabel DBusServerAuthenticationObserverPropertyInfo = "authentication-observer" type AttrOrigin DBusServerAuthenticationObserverPropertyInfo = DBusServer attrGet _ = getDBusServerAuthenticationObserver attrSet _ = undefined attrConstruct _ = constructDBusServerAuthenticationObserver attrClear _ = undefined #endif -- VVV Prop "client-address" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable] -- Nullable: (Just False,Nothing) {- | Get the value of the “@client-address@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusServer #clientAddress @ -} getDBusServerClientAddress :: (MonadIO m, IsDBusServer o) => o -> m T.Text getDBusServerClientAddress obj = liftIO $ checkUnexpectedNothing "getDBusServerClientAddress" $ B.Properties.getObjectPropertyString obj "client-address" #if ENABLE_OVERLOADING data DBusServerClientAddressPropertyInfo instance AttrInfo DBusServerClientAddressPropertyInfo where type AttrAllowedOps DBusServerClientAddressPropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint DBusServerClientAddressPropertyInfo = (~) () type AttrBaseTypeConstraint DBusServerClientAddressPropertyInfo = IsDBusServer type AttrGetType DBusServerClientAddressPropertyInfo = T.Text type AttrLabel DBusServerClientAddressPropertyInfo = "client-address" type AttrOrigin DBusServerClientAddressPropertyInfo = DBusServer attrGet _ = getDBusServerClientAddress attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "flags" -- Type: TInterface (Name {namespace = "Gio", name = "DBusServerFlags"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusServer #flags @ -} getDBusServerFlags :: (MonadIO m, IsDBusServer o) => o -> m [Gio.Flags.DBusServerFlags] getDBusServerFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" {- | Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructDBusServerFlags :: (IsDBusServer o) => [Gio.Flags.DBusServerFlags] -> IO (GValueConstruct o) constructDBusServerFlags val = B.Properties.constructObjectPropertyFlags "flags" val #if ENABLE_OVERLOADING data DBusServerFlagsPropertyInfo instance AttrInfo DBusServerFlagsPropertyInfo where type AttrAllowedOps DBusServerFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint DBusServerFlagsPropertyInfo = (~) [Gio.Flags.DBusServerFlags] type AttrBaseTypeConstraint DBusServerFlagsPropertyInfo = IsDBusServer type AttrGetType DBusServerFlagsPropertyInfo = [Gio.Flags.DBusServerFlags] type AttrLabel DBusServerFlagsPropertyInfo = "flags" type AttrOrigin DBusServerFlagsPropertyInfo = DBusServer attrGet _ = getDBusServerFlags attrSet _ = undefined attrConstruct _ = constructDBusServerFlags attrClear _ = undefined #endif -- VVV Prop "guid" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@guid@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusServer #guid @ -} getDBusServerGuid :: (MonadIO m, IsDBusServer o) => o -> m T.Text getDBusServerGuid obj = liftIO $ checkUnexpectedNothing "getDBusServerGuid" $ B.Properties.getObjectPropertyString obj "guid" {- | Construct a `GValueConstruct` with valid value for the “@guid@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructDBusServerGuid :: (IsDBusServer o) => T.Text -> IO (GValueConstruct o) constructDBusServerGuid val = B.Properties.constructObjectPropertyString "guid" (Just val) #if ENABLE_OVERLOADING data DBusServerGuidPropertyInfo instance AttrInfo DBusServerGuidPropertyInfo where type AttrAllowedOps DBusServerGuidPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint DBusServerGuidPropertyInfo = (~) T.Text type AttrBaseTypeConstraint DBusServerGuidPropertyInfo = IsDBusServer type AttrGetType DBusServerGuidPropertyInfo = T.Text type AttrLabel DBusServerGuidPropertyInfo = "guid" type AttrOrigin DBusServerGuidPropertyInfo = DBusServer attrGet _ = getDBusServerGuid attrSet _ = undefined attrConstruct _ = constructDBusServerGuid attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList DBusServer type instance O.AttributeList DBusServer = DBusServerAttributeList type DBusServerAttributeList = ('[ '("active", DBusServerActivePropertyInfo), '("address", DBusServerAddressPropertyInfo), '("authenticationObserver", DBusServerAuthenticationObserverPropertyInfo), '("clientAddress", DBusServerClientAddressPropertyInfo), '("flags", DBusServerFlagsPropertyInfo), '("guid", DBusServerGuidPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING dBusServerActive :: AttrLabelProxy "active" dBusServerActive = AttrLabelProxy dBusServerAddress :: AttrLabelProxy "address" dBusServerAddress = AttrLabelProxy dBusServerAuthenticationObserver :: AttrLabelProxy "authenticationObserver" dBusServerAuthenticationObserver = AttrLabelProxy dBusServerClientAddress :: AttrLabelProxy "clientAddress" dBusServerClientAddress = AttrLabelProxy dBusServerFlags :: AttrLabelProxy "flags" dBusServerFlags = AttrLabelProxy dBusServerGuid :: AttrLabelProxy "guid" dBusServerGuid = AttrLabelProxy #endif #if ENABLE_OVERLOADING data DBusServerNewConnectionSignalInfo instance SignalInfo DBusServerNewConnectionSignalInfo where type HaskellCallbackType DBusServerNewConnectionSignalInfo = DBusServerNewConnectionCallback connectSignal _ obj cb connectMode = do let cb' = wrap_DBusServerNewConnectionCallback cb cb'' <- mk_DBusServerNewConnectionCallback cb' connectSignalFunPtr obj "new-connection" cb'' connectMode type instance O.SignalList DBusServer = DBusServerSignalList type DBusServerSignalList = ('[ '("newConnection", DBusServerNewConnectionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method DBusServer::new_sync -- method type : Constructor -- Args : [Arg {argCName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A D-Bus address.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusServerFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags from the #GDBusServerFlags enumeration.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A D-Bus GUID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "observer", argType = TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GDBusAuthObserver or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GCancellable or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusServer"})) -- throws : True -- Skip return : False foreign import ccall "g_dbus_server_new_sync" g_dbus_server_new_sync :: CString -> -- address : TBasicType TUTF8 CUInt -> -- flags : TInterface (Name {namespace = "Gio", name = "DBusServerFlags"}) CString -> -- guid : TBasicType TUTF8 Ptr Gio.DBusAuthObserver.DBusAuthObserver -> -- observer : TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}) Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) Ptr (Ptr GError) -> -- error IO (Ptr DBusServer) {- | Creates a new D-Bus server that listens on the first address in /@address@/ that works. Once constructed, you can use 'GI.Gio.Objects.DBusServer.dBusServerGetClientAddress' to get a D-Bus address string that clients can use to connect. Connect to the 'GI.Gio.Objects.DBusServer.DBusServer'::@/new-connection/@ signal to handle incoming connections. The returned 'GI.Gio.Objects.DBusServer.DBusServer' isn\'t active - you have to start it with 'GI.Gio.Objects.DBusServer.dBusServerStart'. 'GI.Gio.Objects.DBusServer.DBusServer' is used in this [example][gdbus-peer-to-peer]. This is a synchronous failable constructor. See @/g_dbus_server_new()/@ for the asynchronous version. /Since: 2.26/ -} dBusServerNewSync :: (B.CallStack.HasCallStack, MonadIO m, Gio.DBusAuthObserver.IsDBusAuthObserver a, Gio.Cancellable.IsCancellable b) => T.Text {- ^ /@address@/: A D-Bus address. -} -> [Gio.Flags.DBusServerFlags] {- ^ /@flags@/: Flags from the 'GI.Gio.Flags.DBusServerFlags' enumeration. -} -> T.Text {- ^ /@guid@/: A D-Bus GUID. -} -> Maybe (a) {- ^ /@observer@/: A 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' or 'Nothing'. -} -> Maybe (b) {- ^ /@cancellable@/: A 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing'. -} -> m DBusServer {- ^ __Returns:__ A 'GI.Gio.Objects.DBusServer.DBusServer' or 'Nothing' if /@error@/ is set. Free with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusServerNewSync address flags guid observer cancellable = liftIO $ do address' <- textToCString address let flags' = gflagsToWord flags guid' <- textToCString guid maybeObserver <- case observer of Nothing -> return nullPtr Just jObserver -> do jObserver' <- unsafeManagedPtrCastPtr jObserver return jObserver' maybeCancellable <- case cancellable of Nothing -> return nullPtr Just jCancellable -> do jCancellable' <- unsafeManagedPtrCastPtr jCancellable return jCancellable' onException (do result <- propagateGError $ g_dbus_server_new_sync address' flags' guid' maybeObserver maybeCancellable checkUnexpectedReturnNULL "dBusServerNewSync" result result' <- (wrapObject DBusServer) result whenJust observer touchManagedPtr whenJust cancellable touchManagedPtr freeMem address' freeMem guid' return result' ) (do freeMem address' freeMem guid' ) #if ENABLE_OVERLOADING #endif -- method DBusServer::get_client_address -- method type : OrdinaryMethod -- Args : [Arg {argCName = "server", argType = TInterface (Name {namespace = "Gio", name = "DBusServer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusServer.", 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_server_get_client_address" g_dbus_server_get_client_address :: Ptr DBusServer -> -- server : TInterface (Name {namespace = "Gio", name = "DBusServer"}) IO CString {- | Gets a string that can be used by clients to connect to /@server@/. /Since: 2.26/ -} dBusServerGetClientAddress :: (B.CallStack.HasCallStack, MonadIO m, IsDBusServer a) => a {- ^ /@server@/: A 'GI.Gio.Objects.DBusServer.DBusServer'. -} -> m T.Text {- ^ __Returns:__ A D-Bus address string. Do not free, the string is owned by /@server@/. -} dBusServerGetClientAddress server = liftIO $ do server' <- unsafeManagedPtrCastPtr server result <- g_dbus_server_get_client_address server' checkUnexpectedReturnNULL "dBusServerGetClientAddress" result result' <- cstringToText result touchManagedPtr server return result' #if ENABLE_OVERLOADING data DBusServerGetClientAddressMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusServer a) => O.MethodInfo DBusServerGetClientAddressMethodInfo a signature where overloadedMethod _ = dBusServerGetClientAddress #endif -- method DBusServer::get_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "server", argType = TInterface (Name {namespace = "Gio", name = "DBusServer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusServer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusServerFlags"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_server_get_flags" g_dbus_server_get_flags :: Ptr DBusServer -> -- server : TInterface (Name {namespace = "Gio", name = "DBusServer"}) IO CUInt {- | Gets the flags for /@server@/. /Since: 2.26/ -} dBusServerGetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsDBusServer a) => a {- ^ /@server@/: A 'GI.Gio.Objects.DBusServer.DBusServer'. -} -> m [Gio.Flags.DBusServerFlags] {- ^ __Returns:__ A set of flags from the 'GI.Gio.Flags.DBusServerFlags' enumeration. -} dBusServerGetFlags server = liftIO $ do server' <- unsafeManagedPtrCastPtr server result <- g_dbus_server_get_flags server' let result' = wordToGFlags result touchManagedPtr server return result' #if ENABLE_OVERLOADING data DBusServerGetFlagsMethodInfo instance (signature ~ (m [Gio.Flags.DBusServerFlags]), MonadIO m, IsDBusServer a) => O.MethodInfo DBusServerGetFlagsMethodInfo a signature where overloadedMethod _ = dBusServerGetFlags #endif -- method DBusServer::get_guid -- method type : OrdinaryMethod -- Args : [Arg {argCName = "server", argType = TInterface (Name {namespace = "Gio", name = "DBusServer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusServer.", 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_server_get_guid" g_dbus_server_get_guid :: Ptr DBusServer -> -- server : TInterface (Name {namespace = "Gio", name = "DBusServer"}) IO CString {- | Gets the GUID for /@server@/. /Since: 2.26/ -} dBusServerGetGuid :: (B.CallStack.HasCallStack, MonadIO m, IsDBusServer a) => a {- ^ /@server@/: A 'GI.Gio.Objects.DBusServer.DBusServer'. -} -> m T.Text {- ^ __Returns:__ A D-Bus GUID. Do not free this string, it is owned by /@server@/. -} dBusServerGetGuid server = liftIO $ do server' <- unsafeManagedPtrCastPtr server result <- g_dbus_server_get_guid server' checkUnexpectedReturnNULL "dBusServerGetGuid" result result' <- cstringToText result touchManagedPtr server return result' #if ENABLE_OVERLOADING data DBusServerGetGuidMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusServer a) => O.MethodInfo DBusServerGetGuidMethodInfo a signature where overloadedMethod _ = dBusServerGetGuid #endif -- method DBusServer::is_active -- method type : OrdinaryMethod -- Args : [Arg {argCName = "server", argType = TInterface (Name {namespace = "Gio", name = "DBusServer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusServer.", 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_server_is_active" g_dbus_server_is_active :: Ptr DBusServer -> -- server : TInterface (Name {namespace = "Gio", name = "DBusServer"}) IO CInt {- | Gets whether /@server@/ is active. /Since: 2.26/ -} dBusServerIsActive :: (B.CallStack.HasCallStack, MonadIO m, IsDBusServer a) => a {- ^ /@server@/: A 'GI.Gio.Objects.DBusServer.DBusServer'. -} -> m Bool {- ^ __Returns:__ 'True' if server is active, 'False' otherwise. -} dBusServerIsActive server = liftIO $ do server' <- unsafeManagedPtrCastPtr server result <- g_dbus_server_is_active server' let result' = (/= 0) result touchManagedPtr server return result' #if ENABLE_OVERLOADING data DBusServerIsActiveMethodInfo instance (signature ~ (m Bool), MonadIO m, IsDBusServer a) => O.MethodInfo DBusServerIsActiveMethodInfo a signature where overloadedMethod _ = dBusServerIsActive #endif -- method DBusServer::start -- method type : OrdinaryMethod -- Args : [Arg {argCName = "server", argType = TInterface (Name {namespace = "Gio", name = "DBusServer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusServer.", 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_server_start" g_dbus_server_start :: Ptr DBusServer -> -- server : TInterface (Name {namespace = "Gio", name = "DBusServer"}) IO () {- | Starts /@server@/. /Since: 2.26/ -} dBusServerStart :: (B.CallStack.HasCallStack, MonadIO m, IsDBusServer a) => a {- ^ /@server@/: A 'GI.Gio.Objects.DBusServer.DBusServer'. -} -> m () dBusServerStart server = liftIO $ do server' <- unsafeManagedPtrCastPtr server g_dbus_server_start server' touchManagedPtr server return () #if ENABLE_OVERLOADING data DBusServerStartMethodInfo instance (signature ~ (m ()), MonadIO m, IsDBusServer a) => O.MethodInfo DBusServerStartMethodInfo a signature where overloadedMethod _ = dBusServerStart #endif -- method DBusServer::stop -- method type : OrdinaryMethod -- Args : [Arg {argCName = "server", argType = TInterface (Name {namespace = "Gio", name = "DBusServer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusServer.", 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_server_stop" g_dbus_server_stop :: Ptr DBusServer -> -- server : TInterface (Name {namespace = "Gio", name = "DBusServer"}) IO () {- | Stops /@server@/. /Since: 2.26/ -} dBusServerStop :: (B.CallStack.HasCallStack, MonadIO m, IsDBusServer a) => a {- ^ /@server@/: A 'GI.Gio.Objects.DBusServer.DBusServer'. -} -> m () dBusServerStop server = liftIO $ do server' <- unsafeManagedPtrCastPtr server g_dbus_server_stop server' touchManagedPtr server return () #if ENABLE_OVERLOADING data DBusServerStopMethodInfo instance (signature ~ (m ()), MonadIO m, IsDBusServer a) => O.MethodInfo DBusServerStopMethodInfo a signature where overloadedMethod _ = dBusServerStop #endif