{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.Gio.Objects.SocketService
    ( 

-- * Exported types
    SocketService(..)                       ,
    SocketServiceK                          ,
    toSocketService                         ,
    noSocketService                         ,


 -- * Methods
-- ** socketServiceIsActive
    socketServiceIsActive                   ,


-- ** socketServiceNew
    socketServiceNew                        ,


-- ** socketServiceStart
    socketServiceStart                      ,


-- ** socketServiceStop
    socketServiceStop                       ,




 -- * Signals
-- ** Incoming
    SocketServiceIncomingCallback           ,
    SocketServiceIncomingCallbackC          ,
    SocketServiceIncomingSignalInfo         ,
    afterSocketServiceIncoming              ,
    mkSocketServiceIncomingCallback         ,
    noSocketServiceIncomingCallback         ,
    onSocketServiceIncoming                 ,
    socketServiceIncomingCallbackWrapper    ,
    socketServiceIncomingClosure            ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.Gio.Types
import GI.Gio.Callbacks
import qualified GI.GObject as GObject

newtype SocketService = SocketService (ForeignPtr SocketService)
foreign import ccall "g_socket_service_get_type"
    c_g_socket_service_get_type :: IO GType

type instance ParentTypes SocketService = SocketServiceParentTypes
type SocketServiceParentTypes = '[SocketListener, GObject.Object]

instance GObject SocketService where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_g_socket_service_get_type
    

class GObject o => SocketServiceK o
instance (GObject o, IsDescendantOf SocketService o) => SocketServiceK o

toSocketService :: SocketServiceK o => o -> IO SocketService
toSocketService = unsafeCastTo SocketService

noSocketService :: Maybe SocketService
noSocketService = Nothing

-- signal SocketService::incoming
type SocketServiceIncomingCallback =
    SocketConnection ->
    Maybe GObject.Object ->
    IO Bool

noSocketServiceIncomingCallback :: Maybe SocketServiceIncomingCallback
noSocketServiceIncomingCallback = Nothing

type SocketServiceIncomingCallbackC =
    Ptr () ->                               -- object
    Ptr SocketConnection ->
    Ptr GObject.Object ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkSocketServiceIncomingCallback :: SocketServiceIncomingCallbackC -> IO (FunPtr SocketServiceIncomingCallbackC)

socketServiceIncomingClosure :: SocketServiceIncomingCallback -> IO Closure
socketServiceIncomingClosure cb = newCClosure =<< mkSocketServiceIncomingCallback wrapped
    where wrapped = socketServiceIncomingCallbackWrapper cb

socketServiceIncomingCallbackWrapper ::
    SocketServiceIncomingCallback ->
    Ptr () ->
    Ptr SocketConnection ->
    Ptr GObject.Object ->
    Ptr () ->
    IO CInt
socketServiceIncomingCallbackWrapper _cb _ connection source_object _ = do
    connection' <- (newObject SocketConnection) connection
    maybeSource_object <-
        if source_object == nullPtr
        then return Nothing
        else do
            source_object' <- (newObject GObject.Object) source_object
            return $ Just source_object'
    result <- _cb  connection' maybeSource_object
    let result' = (fromIntegral . fromEnum) result
    return result'

onSocketServiceIncoming :: (GObject a, MonadIO m) => a -> SocketServiceIncomingCallback -> m SignalHandlerId
onSocketServiceIncoming obj cb = liftIO $ connectSocketServiceIncoming obj cb SignalConnectBefore
afterSocketServiceIncoming :: (GObject a, MonadIO m) => a -> SocketServiceIncomingCallback -> m SignalHandlerId
afterSocketServiceIncoming obj cb = connectSocketServiceIncoming obj cb SignalConnectAfter

connectSocketServiceIncoming :: (GObject a, MonadIO m) =>
                                a -> SocketServiceIncomingCallback -> SignalConnectMode -> m SignalHandlerId
connectSocketServiceIncoming obj cb after = liftIO $ do
    cb' <- mkSocketServiceIncomingCallback (socketServiceIncomingCallbackWrapper cb)
    connectSignalFunPtr obj "incoming" cb' after

type instance AttributeList SocketService = SocketServiceAttributeList
type SocketServiceAttributeList = ('[ '("listen-backlog", SocketListenerListenBacklogPropertyInfo)] :: [(Symbol, *)])

data SocketServiceIncomingSignalInfo
instance SignalInfo SocketServiceIncomingSignalInfo where
    type HaskellCallbackType SocketServiceIncomingSignalInfo = SocketServiceIncomingCallback
    connectSignal _ = connectSocketServiceIncoming

type instance SignalList SocketService = SocketServiceSignalList
type SocketServiceSignalList = ('[ '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method SocketService::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TInterface "Gio" "SocketService"
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_new" g_socket_service_new :: 
    IO (Ptr SocketService)


socketServiceNew ::
    (MonadIO m) =>
    m SocketService
socketServiceNew  = liftIO $ do
    result <- g_socket_service_new
    checkUnexpectedReturnNULL "g_socket_service_new" result
    result' <- (wrapObject SocketService) result
    return result'

-- method SocketService::is_active
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_is_active" g_socket_service_is_active :: 
    Ptr SocketService ->                    -- _obj : TInterface "Gio" "SocketService"
    IO CInt


socketServiceIsActive ::
    (MonadIO m, SocketServiceK a) =>
    a ->                                    -- _obj
    m Bool
socketServiceIsActive _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- g_socket_service_is_active _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method SocketService::start
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_start" g_socket_service_start :: 
    Ptr SocketService ->                    -- _obj : TInterface "Gio" "SocketService"
    IO ()


socketServiceStart ::
    (MonadIO m, SocketServiceK a) =>
    a ->                                    -- _obj
    m ()
socketServiceStart _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    g_socket_service_start _obj'
    touchManagedPtr _obj
    return ()

-- method SocketService::stop
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_stop" g_socket_service_stop :: 
    Ptr SocketService ->                    -- _obj : TInterface "Gio" "SocketService"
    IO ()


socketServiceStop ::
    (MonadIO m, SocketServiceK a) =>
    a ->                                    -- _obj
    m ()
socketServiceStop _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    g_socket_service_stop _obj'
    touchManagedPtr _obj
    return ()