{- |
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.ThreadedSocketService
    ( 

-- * Exported types
    ThreadedSocketService(..)               ,
    ThreadedSocketServiceK                  ,
    toThreadedSocketService                 ,
    noThreadedSocketService                 ,


 -- * Methods
-- ** threadedSocketServiceNew
    threadedSocketServiceNew                ,




 -- * Properties
-- ** MaxThreads
    ThreadedSocketServiceMaxThreadsPropertyInfo,
    constructThreadedSocketServiceMaxThreads,
    getThreadedSocketServiceMaxThreads      ,




 -- * Signals
-- ** Run
    ThreadedSocketServiceRunCallback        ,
    ThreadedSocketServiceRunCallbackC       ,
    ThreadedSocketServiceRunSignalInfo      ,
    afterThreadedSocketServiceRun           ,
    mkThreadedSocketServiceRunCallback      ,
    noThreadedSocketServiceRunCallback      ,
    onThreadedSocketServiceRun              ,
    threadedSocketServiceRunCallbackWrapper ,
    threadedSocketServiceRunClosure         ,




    ) 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 ThreadedSocketService = ThreadedSocketService (ForeignPtr ThreadedSocketService)
foreign import ccall "g_threaded_socket_service_get_type"
    c_g_threaded_socket_service_get_type :: IO GType

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

instance GObject ThreadedSocketService where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_g_threaded_socket_service_get_type
    

class GObject o => ThreadedSocketServiceK o
instance (GObject o, IsDescendantOf ThreadedSocketService o) => ThreadedSocketServiceK o

toThreadedSocketService :: ThreadedSocketServiceK o => o -> IO ThreadedSocketService
toThreadedSocketService = unsafeCastTo ThreadedSocketService

noThreadedSocketService :: Maybe ThreadedSocketService
noThreadedSocketService = Nothing

-- signal ThreadedSocketService::run
type ThreadedSocketServiceRunCallback =
    SocketConnection ->
    GObject.Object ->
    IO Bool

noThreadedSocketServiceRunCallback :: Maybe ThreadedSocketServiceRunCallback
noThreadedSocketServiceRunCallback = Nothing

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

foreign import ccall "wrapper"
    mkThreadedSocketServiceRunCallback :: ThreadedSocketServiceRunCallbackC -> IO (FunPtr ThreadedSocketServiceRunCallbackC)

threadedSocketServiceRunClosure :: ThreadedSocketServiceRunCallback -> IO Closure
threadedSocketServiceRunClosure cb = newCClosure =<< mkThreadedSocketServiceRunCallback wrapped
    where wrapped = threadedSocketServiceRunCallbackWrapper cb

threadedSocketServiceRunCallbackWrapper ::
    ThreadedSocketServiceRunCallback ->
    Ptr () ->
    Ptr SocketConnection ->
    Ptr GObject.Object ->
    Ptr () ->
    IO CInt
threadedSocketServiceRunCallbackWrapper _cb _ connection source_object _ = do
    connection' <- (newObject SocketConnection) connection
    source_object' <- (newObject GObject.Object) source_object
    result <- _cb  connection' source_object'
    let result' = (fromIntegral . fromEnum) result
    return result'

onThreadedSocketServiceRun :: (GObject a, MonadIO m) => a -> ThreadedSocketServiceRunCallback -> m SignalHandlerId
onThreadedSocketServiceRun obj cb = liftIO $ connectThreadedSocketServiceRun obj cb SignalConnectBefore
afterThreadedSocketServiceRun :: (GObject a, MonadIO m) => a -> ThreadedSocketServiceRunCallback -> m SignalHandlerId
afterThreadedSocketServiceRun obj cb = connectThreadedSocketServiceRun obj cb SignalConnectAfter

connectThreadedSocketServiceRun :: (GObject a, MonadIO m) =>
                                   a -> ThreadedSocketServiceRunCallback -> SignalConnectMode -> m SignalHandlerId
connectThreadedSocketServiceRun obj cb after = liftIO $ do
    cb' <- mkThreadedSocketServiceRunCallback (threadedSocketServiceRunCallbackWrapper cb)
    connectSignalFunPtr obj "run" cb' after

-- VVV Prop "max-threads"
   -- Type: TBasicType TInt32
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getThreadedSocketServiceMaxThreads :: (MonadIO m, ThreadedSocketServiceK o) => o -> m Int32
getThreadedSocketServiceMaxThreads obj = liftIO $ getObjectPropertyCInt obj "max-threads"

constructThreadedSocketServiceMaxThreads :: Int32 -> IO ([Char], GValue)
constructThreadedSocketServiceMaxThreads val = constructObjectPropertyCInt "max-threads" val

data ThreadedSocketServiceMaxThreadsPropertyInfo
instance AttrInfo ThreadedSocketServiceMaxThreadsPropertyInfo where
    type AttrAllowedOps ThreadedSocketServiceMaxThreadsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ThreadedSocketServiceMaxThreadsPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint ThreadedSocketServiceMaxThreadsPropertyInfo = ThreadedSocketServiceK
    type AttrGetType ThreadedSocketServiceMaxThreadsPropertyInfo = Int32
    type AttrLabel ThreadedSocketServiceMaxThreadsPropertyInfo = "ThreadedSocketService::max-threads"
    attrGet _ = getThreadedSocketServiceMaxThreads
    attrSet _ = undefined
    attrConstruct _ = constructThreadedSocketServiceMaxThreads

type instance AttributeList ThreadedSocketService = ThreadedSocketServiceAttributeList
type ThreadedSocketServiceAttributeList = ('[ '("listen-backlog", SocketListenerListenBacklogPropertyInfo), '("max-threads", ThreadedSocketServiceMaxThreadsPropertyInfo)] :: [(Symbol, *)])

data ThreadedSocketServiceRunSignalInfo
instance SignalInfo ThreadedSocketServiceRunSignalInfo where
    type HaskellCallbackType ThreadedSocketServiceRunSignalInfo = ThreadedSocketServiceRunCallback
    connectSignal _ = connectThreadedSocketServiceRun

type instance SignalList ThreadedSocketService = ThreadedSocketServiceSignalList
type ThreadedSocketServiceSignalList = ('[ '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("run", ThreadedSocketServiceRunSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method ThreadedSocketService::new
-- method type : Constructor
-- Args : [Arg {argName = "max_threads", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "max_threads", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gio" "ThreadedSocketService"
-- throws : False
-- Skip return : False

foreign import ccall "g_threaded_socket_service_new" g_threaded_socket_service_new :: 
    Int32 ->                                -- max_threads : TBasicType TInt32
    IO (Ptr ThreadedSocketService)


threadedSocketServiceNew ::
    (MonadIO m) =>
    Int32 ->                                -- max_threads
    m ThreadedSocketService
threadedSocketServiceNew max_threads = liftIO $ do
    result <- g_threaded_socket_service_new max_threads
    checkUnexpectedReturnNULL "g_threaded_socket_service_new" result
    result' <- (wrapObject ThreadedSocketService) result
    return result'