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

The client for a 'GI.Dbusmenu.Objects.Server.Server' creating a shared
	object set of 'GI.Dbusmenu.Objects.Menuitem.Menuitem' objects.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Dbusmenu.Objects.Client
    ( 

-- * Exported types
    Client(..)                              ,
    IsClient                                ,
    toClient                                ,
    noClient                                ,


 -- * Methods
-- ** addTypeHandler #method:addTypeHandler#

#if ENABLE_OVERLOADING
    ClientAddTypeHandlerMethodInfo          ,
#endif
    clientAddTypeHandler                    ,


-- ** addTypeHandlerFull #method:addTypeHandlerFull#

#if ENABLE_OVERLOADING
    ClientAddTypeHandlerFullMethodInfo      ,
#endif
    clientAddTypeHandlerFull                ,


-- ** getIconPaths #method:getIconPaths#

#if ENABLE_OVERLOADING
    ClientGetIconPathsMethodInfo            ,
#endif
    clientGetIconPaths                      ,


-- ** getRoot #method:getRoot#

#if ENABLE_OVERLOADING
    ClientGetRootMethodInfo                 ,
#endif
    clientGetRoot                           ,


-- ** getStatus #method:getStatus#

#if ENABLE_OVERLOADING
    ClientGetStatusMethodInfo               ,
#endif
    clientGetStatus                         ,


-- ** getTextDirection #method:getTextDirection#

#if ENABLE_OVERLOADING
    ClientGetTextDirectionMethodInfo        ,
#endif
    clientGetTextDirection                  ,


-- ** new #method:new#

    clientNew                               ,




 -- * Properties
-- ** dbusName #attr:dbusName#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ClientDbusNamePropertyInfo              ,
#endif
#if ENABLE_OVERLOADING
    clientDbusName                          ,
#endif
    constructClientDbusName                 ,
    getClientDbusName                       ,


-- ** dbusObject #attr:dbusObject#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ClientDbusObjectPropertyInfo            ,
#endif
#if ENABLE_OVERLOADING
    clientDbusObject                        ,
#endif
    constructClientDbusObject               ,
    getClientDbusObject                     ,


-- ** groupEvents #attr:groupEvents#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ClientGroupEventsPropertyInfo           ,
#endif
#if ENABLE_OVERLOADING
    clientGroupEvents                       ,
#endif
    constructClientGroupEvents              ,
    getClientGroupEvents                    ,
    setClientGroupEvents                    ,




 -- * Signals
-- ** eventResult #signal:eventResult#

    C_ClientEventResultCallback             ,
    ClientEventResultCallback               ,
#if ENABLE_OVERLOADING
    ClientEventResultSignalInfo             ,
#endif
    afterClientEventResult                  ,
    genClosure_ClientEventResult            ,
    mk_ClientEventResultCallback            ,
    noClientEventResultCallback             ,
    onClientEventResult                     ,
    wrap_ClientEventResultCallback          ,


-- ** iconThemeDirsChanged #signal:iconThemeDirsChanged#

    C_ClientIconThemeDirsChangedCallback    ,
    ClientIconThemeDirsChangedCallback      ,
#if ENABLE_OVERLOADING
    ClientIconThemeDirsChangedSignalInfo    ,
#endif
    afterClientIconThemeDirsChanged         ,
    genClosure_ClientIconThemeDirsChanged   ,
    mk_ClientIconThemeDirsChangedCallback   ,
    noClientIconThemeDirsChangedCallback    ,
    onClientIconThemeDirsChanged            ,
    wrap_ClientIconThemeDirsChangedCallback ,


-- ** itemActivate #signal:itemActivate#

    C_ClientItemActivateCallback            ,
    ClientItemActivateCallback              ,
#if ENABLE_OVERLOADING
    ClientItemActivateSignalInfo            ,
#endif
    afterClientItemActivate                 ,
    genClosure_ClientItemActivate           ,
    mk_ClientItemActivateCallback           ,
    noClientItemActivateCallback            ,
    onClientItemActivate                    ,
    wrap_ClientItemActivateCallback         ,


-- ** layoutUpdated #signal:layoutUpdated#

    C_ClientLayoutUpdatedCallback           ,
    ClientLayoutUpdatedCallback             ,
#if ENABLE_OVERLOADING
    ClientLayoutUpdatedSignalInfo           ,
#endif
    afterClientLayoutUpdated                ,
    genClosure_ClientLayoutUpdated          ,
    mk_ClientLayoutUpdatedCallback          ,
    noClientLayoutUpdatedCallback           ,
    onClientLayoutUpdated                   ,
    wrap_ClientLayoutUpdatedCallback        ,


-- ** newMenuitem #signal:newMenuitem#

    C_ClientNewMenuitemCallback             ,
    ClientNewMenuitemCallback               ,
#if ENABLE_OVERLOADING
    ClientNewMenuitemSignalInfo             ,
#endif
    afterClientNewMenuitem                  ,
    genClosure_ClientNewMenuitem            ,
    mk_ClientNewMenuitemCallback            ,
    noClientNewMenuitemCallback             ,
    onClientNewMenuitem                     ,
    wrap_ClientNewMenuitemCallback          ,


-- ** rootChanged #signal:rootChanged#

    C_ClientRootChangedCallback             ,
    ClientRootChangedCallback               ,
#if ENABLE_OVERLOADING
    ClientRootChangedSignalInfo             ,
#endif
    afterClientRootChanged                  ,
    genClosure_ClientRootChanged            ,
    mk_ClientRootChangedCallback            ,
    noClientRootChangedCallback             ,
    onClientRootChanged                     ,
    wrap_ClientRootChangedCallback          ,




    ) 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.Dbusmenu.Callbacks as Dbusmenu.Callbacks
import {-# SOURCE #-} qualified GI.Dbusmenu.Enums as Dbusmenu.Enums
import {-# SOURCE #-} qualified GI.Dbusmenu.Objects.Menuitem as Dbusmenu.Menuitem
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype Client = Client (ManagedPtr Client)
foreign import ccall "dbusmenu_client_get_type"
    c_dbusmenu_client_get_type :: IO GType

instance GObject Client where
    gobjectType :: Client -> IO GType
gobjectType _ = IO GType
c_dbusmenu_client_get_type
    

-- | Type class for types which can be safely cast to `Client`, for instance with `toClient`.
class GObject o => IsClient o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Client a) =>
    IsClient a
#endif
instance IsClient Client
instance GObject.Object.IsObject Client

-- | Cast to `Client`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toClient :: (MonadIO m, IsClient o) => o -> m Client
toClient :: o -> m Client
toClient = IO Client -> m Client
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Client -> m Client) -> (o -> IO Client) -> o -> m Client
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Client -> Client) -> o -> IO Client
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Client -> Client
Client

-- | A convenience alias for `Nothing` :: `Maybe` `Client`.
noClient :: Maybe Client
noClient :: Maybe Client
noClient = Maybe Client
forall a. Maybe a
Nothing

#if ENABLE_OVERLOADING
type family ResolveClientMethod (t :: Symbol) (o :: *) :: * where
    ResolveClientMethod "addTypeHandler" o = ClientAddTypeHandlerMethodInfo
    ResolveClientMethod "addTypeHandlerFull" o = ClientAddTypeHandlerFullMethodInfo
    ResolveClientMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveClientMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveClientMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveClientMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveClientMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveClientMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveClientMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveClientMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveClientMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveClientMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveClientMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveClientMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveClientMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveClientMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveClientMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveClientMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveClientMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveClientMethod "getIconPaths" o = ClientGetIconPathsMethodInfo
    ResolveClientMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveClientMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveClientMethod "getRoot" o = ClientGetRootMethodInfo
    ResolveClientMethod "getStatus" o = ClientGetStatusMethodInfo
    ResolveClientMethod "getTextDirection" o = ClientGetTextDirectionMethodInfo
    ResolveClientMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveClientMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveClientMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveClientMethod t Client, O.MethodInfo info Client p) => O.IsLabelProxy t (Client -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveClientMethod t Client, O.MethodInfo info Client p) => O.IsLabel t (Client -> 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

#endif

-- signal Client::event-result
{- |
/No description available in the introspection data./
-}
type ClientEventResultCallback =
    GObject.Object.Object
    -> T.Text
    -> GVariant
    -> Word32
    -> Ptr ()
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClientEventResultCallback`@.
noClientEventResultCallback :: Maybe ClientEventResultCallback
noClientEventResultCallback :: Maybe ClientEventResultCallback
noClientEventResultCallback = Maybe ClientEventResultCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ClientEventResultCallback =
    Ptr () ->                               -- object
    Ptr GObject.Object.Object ->
    CString ->
    Ptr GVariant ->
    Word32 ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ClientEventResultCallback`.
foreign import ccall "wrapper"
    mk_ClientEventResultCallback :: C_ClientEventResultCallback -> IO (FunPtr C_ClientEventResultCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ClientEventResult :: ClientEventResultCallback -> IO Closure
genClosure_ClientEventResult :: ClientEventResultCallback -> IO Closure
genClosure_ClientEventResult cb :: ClientEventResultCallback
cb = do
    let cb' :: C_ClientEventResultCallback
cb' = ClientEventResultCallback -> C_ClientEventResultCallback
wrap_ClientEventResultCallback ClientEventResultCallback
cb
    C_ClientEventResultCallback
-> IO (FunPtr C_ClientEventResultCallback)
mk_ClientEventResultCallback C_ClientEventResultCallback
cb' IO (FunPtr C_ClientEventResultCallback)
-> (FunPtr C_ClientEventResultCallback -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientEventResultCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ClientEventResultCallback` into a `C_ClientEventResultCallback`.
wrap_ClientEventResultCallback ::
    ClientEventResultCallback ->
    C_ClientEventResultCallback
wrap_ClientEventResultCallback :: ClientEventResultCallback -> C_ClientEventResultCallback
wrap_ClientEventResultCallback _cb :: ClientEventResultCallback
_cb _ object :: Ptr Object
object p0 :: CString
p0 p1 :: Ptr GVariant
p1 p2 :: Word32
p2 p3 :: Ptr ()
p3 _ = do
    Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
    Text
p0' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
p0
    GVariant
p1' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
p1
    ClientEventResultCallback
_cb  Object
object' Text
p0' GVariant
p1' Word32
p2 Ptr ()
p3


{- |
Connect a signal handler for the “@event-result@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' client #eventResult callback
@
-}
onClientEventResult :: (IsClient a, MonadIO m) => a -> ClientEventResultCallback -> m SignalHandlerId
onClientEventResult :: a -> ClientEventResultCallback -> m SignalHandlerId
onClientEventResult obj :: a
obj cb :: ClientEventResultCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientEventResultCallback
cb' = ClientEventResultCallback -> C_ClientEventResultCallback
wrap_ClientEventResultCallback ClientEventResultCallback
cb
    FunPtr C_ClientEventResultCallback
cb'' <- C_ClientEventResultCallback
-> IO (FunPtr C_ClientEventResultCallback)
mk_ClientEventResultCallback C_ClientEventResultCallback
cb'
    a
-> String
-> FunPtr C_ClientEventResultCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "event-result" FunPtr C_ClientEventResultCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@event-result@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' client #eventResult callback
@
-}
afterClientEventResult :: (IsClient a, MonadIO m) => a -> ClientEventResultCallback -> m SignalHandlerId
afterClientEventResult :: a -> ClientEventResultCallback -> m SignalHandlerId
afterClientEventResult obj :: a
obj cb :: ClientEventResultCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientEventResultCallback
cb' = ClientEventResultCallback -> C_ClientEventResultCallback
wrap_ClientEventResultCallback ClientEventResultCallback
cb
    FunPtr C_ClientEventResultCallback
cb'' <- C_ClientEventResultCallback
-> IO (FunPtr C_ClientEventResultCallback)
mk_ClientEventResultCallback C_ClientEventResultCallback
cb'
    a
-> String
-> FunPtr C_ClientEventResultCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "event-result" FunPtr C_ClientEventResultCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal Client::icon-theme-dirs-changed
{- |
Signaled when the theme directories are changed by the server.
-}
type ClientIconThemeDirsChangedCallback =
    Ptr ()
    {- ^ /@arg1@/: A @/GStrv/@ of theme directories -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClientIconThemeDirsChangedCallback`@.
noClientIconThemeDirsChangedCallback :: Maybe ClientIconThemeDirsChangedCallback
noClientIconThemeDirsChangedCallback :: Maybe ClientIconThemeDirsChangedCallback
noClientIconThemeDirsChangedCallback = Maybe ClientIconThemeDirsChangedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ClientIconThemeDirsChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ClientIconThemeDirsChangedCallback`.
foreign import ccall "wrapper"
    mk_ClientIconThemeDirsChangedCallback :: C_ClientIconThemeDirsChangedCallback -> IO (FunPtr C_ClientIconThemeDirsChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ClientIconThemeDirsChanged :: ClientIconThemeDirsChangedCallback -> IO Closure
genClosure_ClientIconThemeDirsChanged :: ClientIconThemeDirsChangedCallback -> IO Closure
genClosure_ClientIconThemeDirsChanged cb :: ClientIconThemeDirsChangedCallback
cb = do
    let cb' :: C_ClientIconThemeDirsChangedCallback
cb' = ClientIconThemeDirsChangedCallback
-> C_ClientIconThemeDirsChangedCallback
wrap_ClientIconThemeDirsChangedCallback ClientIconThemeDirsChangedCallback
cb
    C_ClientIconThemeDirsChangedCallback
-> IO (FunPtr C_ClientIconThemeDirsChangedCallback)
mk_ClientIconThemeDirsChangedCallback C_ClientIconThemeDirsChangedCallback
cb' IO (FunPtr C_ClientIconThemeDirsChangedCallback)
-> (FunPtr C_ClientIconThemeDirsChangedCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientIconThemeDirsChangedCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ClientIconThemeDirsChangedCallback` into a `C_ClientIconThemeDirsChangedCallback`.
wrap_ClientIconThemeDirsChangedCallback ::
    ClientIconThemeDirsChangedCallback ->
    C_ClientIconThemeDirsChangedCallback
wrap_ClientIconThemeDirsChangedCallback :: ClientIconThemeDirsChangedCallback
-> C_ClientIconThemeDirsChangedCallback
wrap_ClientIconThemeDirsChangedCallback _cb :: ClientIconThemeDirsChangedCallback
_cb _ arg1 :: Ptr ()
arg1 _ = do
    ClientIconThemeDirsChangedCallback
_cb  Ptr ()
arg1


{- |
Connect a signal handler for the “@icon-theme-dirs-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' client #iconThemeDirsChanged callback
@
-}
onClientIconThemeDirsChanged :: (IsClient a, MonadIO m) => a -> ClientIconThemeDirsChangedCallback -> m SignalHandlerId
onClientIconThemeDirsChanged :: a -> ClientIconThemeDirsChangedCallback -> m SignalHandlerId
onClientIconThemeDirsChanged obj :: a
obj cb :: ClientIconThemeDirsChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientIconThemeDirsChangedCallback
cb' = ClientIconThemeDirsChangedCallback
-> C_ClientIconThemeDirsChangedCallback
wrap_ClientIconThemeDirsChangedCallback ClientIconThemeDirsChangedCallback
cb
    FunPtr C_ClientIconThemeDirsChangedCallback
cb'' <- C_ClientIconThemeDirsChangedCallback
-> IO (FunPtr C_ClientIconThemeDirsChangedCallback)
mk_ClientIconThemeDirsChangedCallback C_ClientIconThemeDirsChangedCallback
cb'
    a
-> String
-> FunPtr C_ClientIconThemeDirsChangedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "icon-theme-dirs-changed" FunPtr C_ClientIconThemeDirsChangedCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@icon-theme-dirs-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' client #iconThemeDirsChanged callback
@
-}
afterClientIconThemeDirsChanged :: (IsClient a, MonadIO m) => a -> ClientIconThemeDirsChangedCallback -> m SignalHandlerId
afterClientIconThemeDirsChanged :: a -> ClientIconThemeDirsChangedCallback -> m SignalHandlerId
afterClientIconThemeDirsChanged obj :: a
obj cb :: ClientIconThemeDirsChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientIconThemeDirsChangedCallback
cb' = ClientIconThemeDirsChangedCallback
-> C_ClientIconThemeDirsChangedCallback
wrap_ClientIconThemeDirsChangedCallback ClientIconThemeDirsChangedCallback
cb
    FunPtr C_ClientIconThemeDirsChangedCallback
cb'' <- C_ClientIconThemeDirsChangedCallback
-> IO (FunPtr C_ClientIconThemeDirsChangedCallback)
mk_ClientIconThemeDirsChangedCallback C_ClientIconThemeDirsChangedCallback
cb'
    a
-> String
-> FunPtr C_ClientIconThemeDirsChangedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "icon-theme-dirs-changed" FunPtr C_ClientIconThemeDirsChangedCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal Client::item-activate
{- |
Signaled when the server wants to activate an item in
		order to display the menu.
-}
type ClientItemActivateCallback =
    GObject.Object.Object
    {- ^ /@arg1@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' activated -}
    -> Word32
    {- ^ /@arg2@/: A timestamp that the event happened at -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClientItemActivateCallback`@.
noClientItemActivateCallback :: Maybe ClientItemActivateCallback
noClientItemActivateCallback :: Maybe ClientItemActivateCallback
noClientItemActivateCallback = Maybe ClientItemActivateCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ClientItemActivateCallback =
    Ptr () ->                               -- object
    Ptr GObject.Object.Object ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ClientItemActivateCallback`.
foreign import ccall "wrapper"
    mk_ClientItemActivateCallback :: C_ClientItemActivateCallback -> IO (FunPtr C_ClientItemActivateCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ClientItemActivate :: ClientItemActivateCallback -> IO Closure
genClosure_ClientItemActivate :: ClientItemActivateCallback -> IO Closure
genClosure_ClientItemActivate cb :: ClientItemActivateCallback
cb = do
    let cb' :: C_ClientItemActivateCallback
cb' = ClientItemActivateCallback -> C_ClientItemActivateCallback
wrap_ClientItemActivateCallback ClientItemActivateCallback
cb
    C_ClientItemActivateCallback
-> IO (FunPtr C_ClientItemActivateCallback)
mk_ClientItemActivateCallback C_ClientItemActivateCallback
cb' IO (FunPtr C_ClientItemActivateCallback)
-> (FunPtr C_ClientItemActivateCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientItemActivateCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ClientItemActivateCallback` into a `C_ClientItemActivateCallback`.
wrap_ClientItemActivateCallback ::
    ClientItemActivateCallback ->
    C_ClientItemActivateCallback
wrap_ClientItemActivateCallback :: ClientItemActivateCallback -> C_ClientItemActivateCallback
wrap_ClientItemActivateCallback _cb :: ClientItemActivateCallback
_cb _ arg1 :: Ptr Object
arg1 arg2 :: Word32
arg2 _ = do
    Object
arg1' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
arg1
    ClientItemActivateCallback
_cb  Object
arg1' Word32
arg2


{- |
Connect a signal handler for the “@item-activate@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' client #itemActivate callback
@
-}
onClientItemActivate :: (IsClient a, MonadIO m) => a -> ClientItemActivateCallback -> m SignalHandlerId
onClientItemActivate :: a -> ClientItemActivateCallback -> m SignalHandlerId
onClientItemActivate obj :: a
obj cb :: ClientItemActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientItemActivateCallback
cb' = ClientItemActivateCallback -> C_ClientItemActivateCallback
wrap_ClientItemActivateCallback ClientItemActivateCallback
cb
    FunPtr C_ClientItemActivateCallback
cb'' <- C_ClientItemActivateCallback
-> IO (FunPtr C_ClientItemActivateCallback)
mk_ClientItemActivateCallback C_ClientItemActivateCallback
cb'
    a
-> String
-> FunPtr C_ClientItemActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "item-activate" FunPtr C_ClientItemActivateCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@item-activate@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' client #itemActivate callback
@
-}
afterClientItemActivate :: (IsClient a, MonadIO m) => a -> ClientItemActivateCallback -> m SignalHandlerId
afterClientItemActivate :: a -> ClientItemActivateCallback -> m SignalHandlerId
afterClientItemActivate obj :: a
obj cb :: ClientItemActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientItemActivateCallback
cb' = ClientItemActivateCallback -> C_ClientItemActivateCallback
wrap_ClientItemActivateCallback ClientItemActivateCallback
cb
    FunPtr C_ClientItemActivateCallback
cb'' <- C_ClientItemActivateCallback
-> IO (FunPtr C_ClientItemActivateCallback)
mk_ClientItemActivateCallback C_ClientItemActivateCallback
cb'
    a
-> String
-> FunPtr C_ClientItemActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "item-activate" FunPtr C_ClientItemActivateCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal Client::layout-updated
{- |
/No description available in the introspection data./
-}
type ClientLayoutUpdatedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClientLayoutUpdatedCallback`@.
noClientLayoutUpdatedCallback :: Maybe ClientLayoutUpdatedCallback
noClientLayoutUpdatedCallback :: Maybe ClientLayoutUpdatedCallback
noClientLayoutUpdatedCallback = Maybe ClientLayoutUpdatedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ClientLayoutUpdatedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ClientLayoutUpdatedCallback`.
foreign import ccall "wrapper"
    mk_ClientLayoutUpdatedCallback :: C_ClientLayoutUpdatedCallback -> IO (FunPtr C_ClientLayoutUpdatedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ClientLayoutUpdated :: ClientLayoutUpdatedCallback -> IO Closure
genClosure_ClientLayoutUpdated :: ClientLayoutUpdatedCallback -> IO Closure
genClosure_ClientLayoutUpdated cb :: ClientLayoutUpdatedCallback
cb = do
    let cb' :: C_ClientLayoutUpdatedCallback
cb' = ClientLayoutUpdatedCallback -> C_ClientLayoutUpdatedCallback
wrap_ClientLayoutUpdatedCallback ClientLayoutUpdatedCallback
cb
    C_ClientLayoutUpdatedCallback
-> IO (FunPtr C_ClientLayoutUpdatedCallback)
mk_ClientLayoutUpdatedCallback C_ClientLayoutUpdatedCallback
cb' IO (FunPtr C_ClientLayoutUpdatedCallback)
-> (FunPtr C_ClientLayoutUpdatedCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientLayoutUpdatedCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ClientLayoutUpdatedCallback` into a `C_ClientLayoutUpdatedCallback`.
wrap_ClientLayoutUpdatedCallback ::
    ClientLayoutUpdatedCallback ->
    C_ClientLayoutUpdatedCallback
wrap_ClientLayoutUpdatedCallback :: ClientLayoutUpdatedCallback -> C_ClientLayoutUpdatedCallback
wrap_ClientLayoutUpdatedCallback _cb :: ClientLayoutUpdatedCallback
_cb _ _ = do
    ClientLayoutUpdatedCallback
_cb 


{- |
Connect a signal handler for the “@layout-updated@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' client #layoutUpdated callback
@
-}
onClientLayoutUpdated :: (IsClient a, MonadIO m) => a -> ClientLayoutUpdatedCallback -> m SignalHandlerId
onClientLayoutUpdated :: a -> ClientLayoutUpdatedCallback -> m SignalHandlerId
onClientLayoutUpdated obj :: a
obj cb :: ClientLayoutUpdatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientLayoutUpdatedCallback
cb' = ClientLayoutUpdatedCallback -> C_ClientLayoutUpdatedCallback
wrap_ClientLayoutUpdatedCallback ClientLayoutUpdatedCallback
cb
    FunPtr C_ClientLayoutUpdatedCallback
cb'' <- C_ClientLayoutUpdatedCallback
-> IO (FunPtr C_ClientLayoutUpdatedCallback)
mk_ClientLayoutUpdatedCallback C_ClientLayoutUpdatedCallback
cb'
    a
-> String
-> FunPtr C_ClientLayoutUpdatedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "layout-updated" FunPtr C_ClientLayoutUpdatedCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@layout-updated@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' client #layoutUpdated callback
@
-}
afterClientLayoutUpdated :: (IsClient a, MonadIO m) => a -> ClientLayoutUpdatedCallback -> m SignalHandlerId
afterClientLayoutUpdated :: a -> ClientLayoutUpdatedCallback -> m SignalHandlerId
afterClientLayoutUpdated obj :: a
obj cb :: ClientLayoutUpdatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientLayoutUpdatedCallback
cb' = ClientLayoutUpdatedCallback -> C_ClientLayoutUpdatedCallback
wrap_ClientLayoutUpdatedCallback ClientLayoutUpdatedCallback
cb
    FunPtr C_ClientLayoutUpdatedCallback
cb'' <- C_ClientLayoutUpdatedCallback
-> IO (FunPtr C_ClientLayoutUpdatedCallback)
mk_ClientLayoutUpdatedCallback C_ClientLayoutUpdatedCallback
cb'
    a
-> String
-> FunPtr C_ClientLayoutUpdatedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "layout-updated" FunPtr C_ClientLayoutUpdatedCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal Client::new-menuitem
{- |
Signaled when the client creates a new menuitem.  This
		doesn\'t mean that it\'s placed anywhere.  The parent that
		it\'s applied to will signal 'GI.Dbusmenu.Objects.Menuitem.Menuitem'::@/child-added/@
		when it gets parented.
-}
type ClientNewMenuitemCallback =
    GObject.Object.Object
    {- ^ /@arg1@/: The new 'GI.Dbusmenu.Objects.Menuitem.Menuitem' created -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClientNewMenuitemCallback`@.
noClientNewMenuitemCallback :: Maybe ClientNewMenuitemCallback
noClientNewMenuitemCallback :: Maybe ClientNewMenuitemCallback
noClientNewMenuitemCallback = Maybe ClientNewMenuitemCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ClientNewMenuitemCallback =
    Ptr () ->                               -- object
    Ptr GObject.Object.Object ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ClientNewMenuitemCallback`.
foreign import ccall "wrapper"
    mk_ClientNewMenuitemCallback :: C_ClientNewMenuitemCallback -> IO (FunPtr C_ClientNewMenuitemCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ClientNewMenuitem :: ClientNewMenuitemCallback -> IO Closure
genClosure_ClientNewMenuitem :: ClientNewMenuitemCallback -> IO Closure
genClosure_ClientNewMenuitem cb :: ClientNewMenuitemCallback
cb = do
    let cb' :: C_ClientNewMenuitemCallback
cb' = ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientNewMenuitemCallback ClientNewMenuitemCallback
cb
    C_ClientNewMenuitemCallback
-> IO (FunPtr C_ClientNewMenuitemCallback)
mk_ClientNewMenuitemCallback C_ClientNewMenuitemCallback
cb' IO (FunPtr C_ClientNewMenuitemCallback)
-> (FunPtr C_ClientNewMenuitemCallback -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientNewMenuitemCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ClientNewMenuitemCallback` into a `C_ClientNewMenuitemCallback`.
wrap_ClientNewMenuitemCallback ::
    ClientNewMenuitemCallback ->
    C_ClientNewMenuitemCallback
wrap_ClientNewMenuitemCallback :: ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientNewMenuitemCallback _cb :: ClientNewMenuitemCallback
_cb _ arg1 :: Ptr Object
arg1 _ = do
    Object
arg1' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
arg1
    ClientNewMenuitemCallback
_cb  Object
arg1'


{- |
Connect a signal handler for the “@new-menuitem@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' client #newMenuitem callback
@
-}
onClientNewMenuitem :: (IsClient a, MonadIO m) => a -> ClientNewMenuitemCallback -> m SignalHandlerId
onClientNewMenuitem :: a -> ClientNewMenuitemCallback -> m SignalHandlerId
onClientNewMenuitem obj :: a
obj cb :: ClientNewMenuitemCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientNewMenuitemCallback
cb' = ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientNewMenuitemCallback ClientNewMenuitemCallback
cb
    FunPtr C_ClientNewMenuitemCallback
cb'' <- C_ClientNewMenuitemCallback
-> IO (FunPtr C_ClientNewMenuitemCallback)
mk_ClientNewMenuitemCallback C_ClientNewMenuitemCallback
cb'
    a
-> String
-> FunPtr C_ClientNewMenuitemCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "new-menuitem" FunPtr C_ClientNewMenuitemCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@new-menuitem@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' client #newMenuitem callback
@
-}
afterClientNewMenuitem :: (IsClient a, MonadIO m) => a -> ClientNewMenuitemCallback -> m SignalHandlerId
afterClientNewMenuitem :: a -> ClientNewMenuitemCallback -> m SignalHandlerId
afterClientNewMenuitem obj :: a
obj cb :: ClientNewMenuitemCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientNewMenuitemCallback
cb' = ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientNewMenuitemCallback ClientNewMenuitemCallback
cb
    FunPtr C_ClientNewMenuitemCallback
cb'' <- C_ClientNewMenuitemCallback
-> IO (FunPtr C_ClientNewMenuitemCallback)
mk_ClientNewMenuitemCallback C_ClientNewMenuitemCallback
cb'
    a
-> String
-> FunPtr C_ClientNewMenuitemCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "new-menuitem" FunPtr C_ClientNewMenuitemCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal Client::root-changed
{- |
The layout has changed in a way that can not be
		represented by the individual items changing as the
		root of this client has changed.
-}
type ClientRootChangedCallback =
    GObject.Object.Object
    {- ^ /@arg1@/: The new root 'GI.Dbusmenu.Objects.Menuitem.Menuitem' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClientRootChangedCallback`@.
noClientRootChangedCallback :: Maybe ClientRootChangedCallback
noClientRootChangedCallback :: Maybe ClientNewMenuitemCallback
noClientRootChangedCallback = Maybe ClientNewMenuitemCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ClientRootChangedCallback =
    Ptr () ->                               -- object
    Ptr GObject.Object.Object ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ClientRootChangedCallback`.
foreign import ccall "wrapper"
    mk_ClientRootChangedCallback :: C_ClientRootChangedCallback -> IO (FunPtr C_ClientRootChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ClientRootChanged :: ClientRootChangedCallback -> IO Closure
genClosure_ClientRootChanged :: ClientNewMenuitemCallback -> IO Closure
genClosure_ClientRootChanged cb :: ClientNewMenuitemCallback
cb = do
    let cb' :: C_ClientNewMenuitemCallback
cb' = ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientRootChangedCallback ClientNewMenuitemCallback
cb
    C_ClientNewMenuitemCallback
-> IO (FunPtr C_ClientNewMenuitemCallback)
mk_ClientRootChangedCallback C_ClientNewMenuitemCallback
cb' IO (FunPtr C_ClientNewMenuitemCallback)
-> (FunPtr C_ClientNewMenuitemCallback -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientNewMenuitemCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ClientRootChangedCallback` into a `C_ClientRootChangedCallback`.
wrap_ClientRootChangedCallback ::
    ClientRootChangedCallback ->
    C_ClientRootChangedCallback
wrap_ClientRootChangedCallback :: ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientRootChangedCallback _cb :: ClientNewMenuitemCallback
_cb _ arg1 :: Ptr Object
arg1 _ = do
    Object
arg1' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
arg1
    ClientNewMenuitemCallback
_cb  Object
arg1'


{- |
Connect a signal handler for the “@root-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' client #rootChanged callback
@
-}
onClientRootChanged :: (IsClient a, MonadIO m) => a -> ClientRootChangedCallback -> m SignalHandlerId
onClientRootChanged :: a -> ClientNewMenuitemCallback -> m SignalHandlerId
onClientRootChanged obj :: a
obj cb :: ClientNewMenuitemCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientNewMenuitemCallback
cb' = ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientRootChangedCallback ClientNewMenuitemCallback
cb
    FunPtr C_ClientNewMenuitemCallback
cb'' <- C_ClientNewMenuitemCallback
-> IO (FunPtr C_ClientNewMenuitemCallback)
mk_ClientRootChangedCallback C_ClientNewMenuitemCallback
cb'
    a
-> String
-> FunPtr C_ClientNewMenuitemCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "root-changed" FunPtr C_ClientNewMenuitemCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@root-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' client #rootChanged callback
@
-}
afterClientRootChanged :: (IsClient a, MonadIO m) => a -> ClientRootChangedCallback -> m SignalHandlerId
afterClientRootChanged :: a -> ClientNewMenuitemCallback -> m SignalHandlerId
afterClientRootChanged obj :: a
obj cb :: ClientNewMenuitemCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ClientNewMenuitemCallback
cb' = ClientNewMenuitemCallback -> C_ClientNewMenuitemCallback
wrap_ClientRootChangedCallback ClientNewMenuitemCallback
cb
    FunPtr C_ClientNewMenuitemCallback
cb'' <- C_ClientNewMenuitemCallback
-> IO (FunPtr C_ClientNewMenuitemCallback)
mk_ClientRootChangedCallback C_ClientNewMenuitemCallback
cb'
    a
-> String
-> FunPtr C_ClientNewMenuitemCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "root-changed" FunPtr C_ClientNewMenuitemCallback
cb'' SignalConnectMode
SignalConnectAfter


-- VVV Prop "dbus-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@dbus-name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' client #dbusName
@
-}
getClientDbusName :: (MonadIO m, IsClient o) => o -> m (Maybe T.Text)
getClientDbusName :: o -> m (Maybe Text)
getClientDbusName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
getObjectPropertyString o
obj "dbus-name"

{- |
Construct a `GValueConstruct` with valid value for the “@dbus-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructClientDbusName :: (IsClient o) => T.Text -> IO (GValueConstruct o)
constructClientDbusName :: Text -> IO (GValueConstruct o)
constructClientDbusName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "dbus-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

#if ENABLE_OVERLOADING
data ClientDbusNamePropertyInfo
instance AttrInfo ClientDbusNamePropertyInfo where
    type AttrAllowedOps ClientDbusNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClientDbusNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ClientDbusNamePropertyInfo = IsClient
    type AttrGetType ClientDbusNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ClientDbusNamePropertyInfo = "dbus-name"
    type AttrOrigin ClientDbusNamePropertyInfo = Client
    attrGet _ = getClientDbusName
    attrSet _ = undefined
    attrConstruct _ = constructClientDbusName
    attrClear _ = undefined
#endif

-- VVV Prop "dbus-object"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@dbus-object@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' client #dbusObject
@
-}
getClientDbusObject :: (MonadIO m, IsClient o) => o -> m (Maybe T.Text)
getClientDbusObject :: o -> m (Maybe Text)
getClientDbusObject obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
getObjectPropertyString o
obj "dbus-object"

{- |
Construct a `GValueConstruct` with valid value for the “@dbus-object@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructClientDbusObject :: (IsClient o) => T.Text -> IO (GValueConstruct o)
constructClientDbusObject :: Text -> IO (GValueConstruct o)
constructClientDbusObject val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "dbus-object" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

#if ENABLE_OVERLOADING
data ClientDbusObjectPropertyInfo
instance AttrInfo ClientDbusObjectPropertyInfo where
    type AttrAllowedOps ClientDbusObjectPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClientDbusObjectPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ClientDbusObjectPropertyInfo = IsClient
    type AttrGetType ClientDbusObjectPropertyInfo = (Maybe T.Text)
    type AttrLabel ClientDbusObjectPropertyInfo = "dbus-object"
    type AttrOrigin ClientDbusObjectPropertyInfo = Client
    attrGet _ = getClientDbusObject
    attrSet _ = undefined
    attrConstruct _ = constructClientDbusObject
    attrClear _ = undefined
#endif

-- VVV Prop "group-events"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@group-events@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' client #groupEvents
@
-}
getClientGroupEvents :: (MonadIO m, IsClient o) => o -> m Bool
getClientGroupEvents :: o -> m Bool
getClientGroupEvents obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "group-events"

{- |
Set the value of the “@group-events@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' client [ #groupEvents 'Data.GI.Base.Attributes.:=' value ]
@
-}
setClientGroupEvents :: (MonadIO m, IsClient o) => o -> Bool -> m ()
setClientGroupEvents :: o -> Bool -> m ()
setClientGroupEvents obj :: o
obj val :: Bool
val = ClientLayoutUpdatedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ClientLayoutUpdatedCallback -> m ())
-> ClientLayoutUpdatedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> ClientLayoutUpdatedCallback
forall a.
GObject a =>
a -> String -> Bool -> ClientLayoutUpdatedCallback
setObjectPropertyBool o
obj "group-events" Bool
val

{- |
Construct a `GValueConstruct` with valid value for the “@group-events@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructClientGroupEvents :: (IsClient o) => Bool -> IO (GValueConstruct o)
constructClientGroupEvents :: Bool -> IO (GValueConstruct o)
constructClientGroupEvents val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "group-events" Bool
val

#if ENABLE_OVERLOADING
data ClientGroupEventsPropertyInfo
instance AttrInfo ClientGroupEventsPropertyInfo where
    type AttrAllowedOps ClientGroupEventsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ClientGroupEventsPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ClientGroupEventsPropertyInfo = IsClient
    type AttrGetType ClientGroupEventsPropertyInfo = Bool
    type AttrLabel ClientGroupEventsPropertyInfo = "group-events"
    type AttrOrigin ClientGroupEventsPropertyInfo = Client
    attrGet _ = getClientGroupEvents
    attrSet _ = setClientGroupEvents
    attrConstruct _ = constructClientGroupEvents
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList Client
type instance O.AttributeList Client = ClientAttributeList
type ClientAttributeList = ('[ '("dbusName", ClientDbusNamePropertyInfo), '("dbusObject", ClientDbusObjectPropertyInfo), '("groupEvents", ClientGroupEventsPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
clientDbusName :: AttrLabelProxy "dbusName"
clientDbusName = AttrLabelProxy

clientDbusObject :: AttrLabelProxy "dbusObject"
clientDbusObject = AttrLabelProxy

clientGroupEvents :: AttrLabelProxy "groupEvents"
clientGroupEvents = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data ClientEventResultSignalInfo
instance SignalInfo ClientEventResultSignalInfo where
    type HaskellCallbackType ClientEventResultSignalInfo = ClientEventResultCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ClientEventResultCallback cb
        cb'' <- mk_ClientEventResultCallback cb'
        connectSignalFunPtr obj "event-result" cb'' connectMode

data ClientIconThemeDirsChangedSignalInfo
instance SignalInfo ClientIconThemeDirsChangedSignalInfo where
    type HaskellCallbackType ClientIconThemeDirsChangedSignalInfo = ClientIconThemeDirsChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ClientIconThemeDirsChangedCallback cb
        cb'' <- mk_ClientIconThemeDirsChangedCallback cb'
        connectSignalFunPtr obj "icon-theme-dirs-changed" cb'' connectMode

data ClientItemActivateSignalInfo
instance SignalInfo ClientItemActivateSignalInfo where
    type HaskellCallbackType ClientItemActivateSignalInfo = ClientItemActivateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ClientItemActivateCallback cb
        cb'' <- mk_ClientItemActivateCallback cb'
        connectSignalFunPtr obj "item-activate" cb'' connectMode

data ClientLayoutUpdatedSignalInfo
instance SignalInfo ClientLayoutUpdatedSignalInfo where
    type HaskellCallbackType ClientLayoutUpdatedSignalInfo = ClientLayoutUpdatedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ClientLayoutUpdatedCallback cb
        cb'' <- mk_ClientLayoutUpdatedCallback cb'
        connectSignalFunPtr obj "layout-updated" cb'' connectMode

data ClientNewMenuitemSignalInfo
instance SignalInfo ClientNewMenuitemSignalInfo where
    type HaskellCallbackType ClientNewMenuitemSignalInfo = ClientNewMenuitemCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ClientNewMenuitemCallback cb
        cb'' <- mk_ClientNewMenuitemCallback cb'
        connectSignalFunPtr obj "new-menuitem" cb'' connectMode

data ClientRootChangedSignalInfo
instance SignalInfo ClientRootChangedSignalInfo where
    type HaskellCallbackType ClientRootChangedSignalInfo = ClientRootChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ClientRootChangedCallback cb
        cb'' <- mk_ClientRootChangedCallback cb'
        connectSignalFunPtr obj "root-changed" cb'' connectMode

type instance O.SignalList Client = ClientSignalList
type ClientSignalList = ('[ '("eventResult", ClientEventResultSignalInfo), '("iconThemeDirsChanged", ClientIconThemeDirsChangedSignalInfo), '("itemActivate", ClientItemActivateSignalInfo), '("layoutUpdated", ClientLayoutUpdatedSignalInfo), '("newMenuitem", ClientNewMenuitemSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rootChanged", ClientRootChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Client::new
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The DBus name for the server to connect to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The object on the server to monitor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Dbusmenu", name = "Client"}))
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_new" dbusmenu_client_new :: 
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- object : TBasicType TUTF8
    IO (Ptr Client)

{- |
This function creates a new client that connects to a specific
server on DBus.  That server is at a specific location sharing
a known object.  The interface is assumed by the code to be
the DBus menu interface.  The newly created client will start
sending out events as it syncs up with the server.
-}
clientNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: The DBus name for the server to connect to -}
    -> T.Text
    {- ^ /@object@/: The object on the server to monitor -}
    -> m Client
    {- ^ __Returns:__ A brand new 'GI.Dbusmenu.Objects.Client.Client' -}
clientNew :: Text -> Text -> m Client
clientNew name :: Text
name object :: Text
object = IO Client -> m Client
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Client -> m Client) -> IO Client -> m Client
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
object' <- Text -> IO CString
textToCString Text
object
    Ptr Client
result <- CString -> CString -> IO (Ptr Client)
dbusmenu_client_new CString
name' CString
object'
    Text -> Ptr Client -> ClientLayoutUpdatedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> ClientLayoutUpdatedCallback
checkUnexpectedReturnNULL "clientNew" Ptr Client
result
    Client
result' <- ((ManagedPtr Client -> Client) -> Ptr Client -> IO Client
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Client -> Client
Client) Ptr Client
result
    CString -> ClientLayoutUpdatedCallback
forall a. Ptr a -> ClientLayoutUpdatedCallback
freeMem CString
name'
    CString -> ClientLayoutUpdatedCallback
forall a. Ptr a -> ClientLayoutUpdatedCallback
freeMem CString
object'
    Client -> IO Client
forall (m :: * -> *) a. Monad m => a -> m a
return Client
result'

#if ENABLE_OVERLOADING
#endif

-- method Client::add_type_handler
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "Dbusmenu", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Client where we're getting types coming in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A text string that will be matched with the 'type'\n    property on incoming menu items", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newfunc", argType = TInterface (Name {namespace = "Dbusmenu", name = "ClientTypeHandler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The function that will be executed with those new\n    items when they come in.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_add_type_handler" dbusmenu_client_add_type_handler :: 
    Ptr Client ->                           -- client : TInterface (Name {namespace = "Dbusmenu", name = "Client"})
    CString ->                              -- type : TBasicType TUTF8
    FunPtr Dbusmenu.Callbacks.C_ClientTypeHandler -> -- newfunc : TInterface (Name {namespace = "Dbusmenu", name = "ClientTypeHandler"})
    IO CInt

{- |
This function connects into the type handling of the 'GI.Dbusmenu.Objects.Client.Client'.
Every new menuitem that comes in immediately gets asked for its
properties.  When we get those properties we check the \'type\'
property and look to see if it matches a handler that is known
by the client.  If so, the /@newfunc@/ function is executed on that
'GI.Dbusmenu.Objects.Menuitem.Menuitem'.  If not, then the DbusmenuClient::new-menuitem
signal is sent.

In the future the known types will be sent to the server so that it
can make choices about the menu item types availble.
-}
clientAddTypeHandler ::
    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
    a
    {- ^ /@client@/: Client where we\'re getting types coming in -}
    -> T.Text
    {- ^ /@type@/: A text string that will be matched with the \'type\'
    property on incoming menu items -}
    -> Dbusmenu.Callbacks.ClientTypeHandler
    {- ^ /@newfunc@/: The function that will be executed with those new
    items when they come in. -}
    -> m Bool
    {- ^ __Returns:__ If registering the new type was successful. -}
clientAddTypeHandler :: a -> Text -> ClientTypeHandler -> m Bool
clientAddTypeHandler client :: a
client type_ :: Text
type_ newfunc :: ClientTypeHandler
newfunc = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Client
client' <- a -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
client
    CString
type_' <- Text -> IO CString
textToCString Text
type_
    FunPtr C_ClientTypeHandler
newfunc' <- C_ClientTypeHandler -> IO (FunPtr C_ClientTypeHandler)
Dbusmenu.Callbacks.mk_ClientTypeHandler (Maybe (Ptr (FunPtr C_ClientTypeHandler))
-> ClientTypeHandler_WithClosures -> C_ClientTypeHandler
Dbusmenu.Callbacks.wrap_ClientTypeHandler Maybe (Ptr (FunPtr C_ClientTypeHandler))
forall a. Maybe a
Nothing (ClientTypeHandler -> ClientTypeHandler_WithClosures
Dbusmenu.Callbacks.drop_closures_ClientTypeHandler ClientTypeHandler
newfunc))
    CInt
result <- Ptr Client -> CString -> FunPtr C_ClientTypeHandler -> IO CInt
dbusmenu_client_add_type_handler Ptr Client
client' CString
type_' FunPtr C_ClientTypeHandler
newfunc'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> ClientLayoutUpdatedCallback
forall a. ManagedPtrNewtype a => a -> ClientLayoutUpdatedCallback
touchManagedPtr a
client
    CString -> ClientLayoutUpdatedCallback
forall a. Ptr a -> ClientLayoutUpdatedCallback
freeMem CString
type_'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data ClientAddTypeHandlerMethodInfo
instance (signature ~ (T.Text -> Dbusmenu.Callbacks.ClientTypeHandler -> m Bool), MonadIO m, IsClient a) => O.MethodInfo ClientAddTypeHandlerMethodInfo a signature where
    overloadedMethod _ = clientAddTypeHandler

#endif

-- method Client::add_type_handler_full
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "Dbusmenu", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Client where we're getting types coming in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A text string that will be matched with the 'type'\n    property on incoming menu items", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newfunc", argType = TInterface (Name {namespace = "Dbusmenu", name = "ClientTypeHandler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The function that will be executed with those new\n    items when they come in.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Data passed to @newfunc when it is called", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A function that is called when the type handler is\n\tremoved (usually on client destruction) which will free\n\tthe resources in @user_data.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_add_type_handler_full" dbusmenu_client_add_type_handler_full :: 
    Ptr Client ->                           -- client : TInterface (Name {namespace = "Dbusmenu", name = "Client"})
    CString ->                              -- type : TBasicType TUTF8
    FunPtr Dbusmenu.Callbacks.C_ClientTypeHandler -> -- newfunc : TInterface (Name {namespace = "Dbusmenu", name = "ClientTypeHandler"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO CInt

{- |
This function connects into the type handling of the 'GI.Dbusmenu.Objects.Client.Client'.
Every new menuitem that comes in immediately gets asked for its
properties.  When we get those properties we check the \'type\'
property and look to see if it matches a handler that is known
by the client.  If so, the /@newfunc@/ function is executed on that
'GI.Dbusmenu.Objects.Menuitem.Menuitem'.  If not, then the DbusmenuClient::new-menuitem
signal is sent.

In the future the known types will be sent to the server so that it
can make choices about the menu item types availble.
-}
clientAddTypeHandlerFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
    a
    {- ^ /@client@/: Client where we\'re getting types coming in -}
    -> T.Text
    {- ^ /@type@/: A text string that will be matched with the \'type\'
    property on incoming menu items -}
    -> Dbusmenu.Callbacks.ClientTypeHandler
    {- ^ /@newfunc@/: The function that will be executed with those new
    items when they come in. -}
    -> m Bool
    {- ^ __Returns:__ If registering the new type was successful. -}
clientAddTypeHandlerFull :: a -> Text -> ClientTypeHandler -> m Bool
clientAddTypeHandlerFull client :: a
client type_ :: Text
type_ newfunc :: ClientTypeHandler
newfunc = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Client
client' <- a -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
client
    CString
type_' <- Text -> IO CString
textToCString Text
type_
    FunPtr C_ClientTypeHandler
newfunc' <- C_ClientTypeHandler -> IO (FunPtr C_ClientTypeHandler)
Dbusmenu.Callbacks.mk_ClientTypeHandler (Maybe (Ptr (FunPtr C_ClientTypeHandler))
-> ClientTypeHandler_WithClosures -> C_ClientTypeHandler
Dbusmenu.Callbacks.wrap_ClientTypeHandler Maybe (Ptr (FunPtr C_ClientTypeHandler))
forall a. Maybe a
Nothing (ClientTypeHandler -> ClientTypeHandler_WithClosures
Dbusmenu.Callbacks.drop_closures_ClientTypeHandler ClientTypeHandler
newfunc))
    let userData :: Ptr ()
userData = FunPtr C_ClientTypeHandler -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ClientTypeHandler
newfunc'
    let destroyFunc :: FunPtr (Ptr a -> ClientLayoutUpdatedCallback)
destroyFunc = FunPtr (Ptr a -> ClientLayoutUpdatedCallback)
forall a. FunPtr (Ptr a -> ClientLayoutUpdatedCallback)
safeFreeFunPtrPtr
    CInt
result <- Ptr Client
-> CString
-> FunPtr C_ClientTypeHandler
-> Ptr ()
-> FunPtr ClientIconThemeDirsChangedCallback
-> IO CInt
dbusmenu_client_add_type_handler_full Ptr Client
client' CString
type_' FunPtr C_ClientTypeHandler
newfunc' Ptr ()
userData FunPtr ClientIconThemeDirsChangedCallback
forall a. FunPtr (Ptr a -> ClientLayoutUpdatedCallback)
destroyFunc
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> ClientLayoutUpdatedCallback
forall a. ManagedPtrNewtype a => a -> ClientLayoutUpdatedCallback
touchManagedPtr a
client
    CString -> ClientLayoutUpdatedCallback
forall a. Ptr a -> ClientLayoutUpdatedCallback
freeMem CString
type_'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data ClientAddTypeHandlerFullMethodInfo
instance (signature ~ (T.Text -> Dbusmenu.Callbacks.ClientTypeHandler -> m Bool), MonadIO m, IsClient a) => O.MethodInfo ClientAddTypeHandlerFullMethodInfo a signature where
    overloadedMethod _ = clientAddTypeHandlerFull

#endif

-- method Client::get_icon_paths
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "Dbusmenu", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuClient to get the icon paths from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_get_icon_paths" dbusmenu_client_get_icon_paths :: 
    Ptr Client ->                           -- client : TInterface (Name {namespace = "Dbusmenu", name = "Client"})
    IO (Ptr CString)

{- |
Gets the stored and exported icon paths from the client.
-}
clientGetIconPaths ::
    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
    a
    {- ^ /@client@/: The 'GI.Dbusmenu.Objects.Client.Client' to get the icon paths from -}
    -> m [T.Text]
    {- ^ __Returns:__ A NULL-terminated list of icon paths with
  memory managed by the client.  Duplicate if you want
  to keep them. -}
clientGetIconPaths :: a -> m [Text]
clientGetIconPaths client :: a
client = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Client
client' <- a -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
client
    Ptr CString
result <- Ptr Client -> IO (Ptr CString)
dbusmenu_client_get_icon_paths Ptr Client
client'
    Text -> Ptr CString -> ClientLayoutUpdatedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> ClientLayoutUpdatedCallback
checkUnexpectedReturnNULL "clientGetIconPaths" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    a -> ClientLayoutUpdatedCallback
forall a. ManagedPtrNewtype a => a -> ClientLayoutUpdatedCallback
touchManagedPtr a
client
    [Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if ENABLE_OVERLOADING
data ClientGetIconPathsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsClient a) => O.MethodInfo ClientGetIconPathsMethodInfo a signature where
    overloadedMethod _ = clientGetIconPaths

#endif

-- method Client::get_root
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "Dbusmenu", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuClient to get the root node from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}))
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_get_root" dbusmenu_client_get_root :: 
    Ptr Client ->                           -- client : TInterface (Name {namespace = "Dbusmenu", name = "Client"})
    IO (Ptr Dbusmenu.Menuitem.Menuitem)

{- |
Grabs the root node for the specified client /@client@/.  This
function may block.  It will block if there is currently a
call to update the layout, it will block on that layout
updated and then return the newly updated layout.  Chances
are that this update is in the queue for the mainloop as
it would have been requested some time ago, but in theory
it could block longer.
-}
clientGetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
    a
    {- ^ /@client@/: The 'GI.Dbusmenu.Objects.Client.Client' to get the root node from -}
    -> m Dbusmenu.Menuitem.Menuitem
    {- ^ __Returns:__ A 'GI.Dbusmenu.Objects.Menuitem.Menuitem' representing the root of
	menu on the server.  If there is no server or there is
	an error receiving its layout it\'ll return @/NULL/@. -}
clientGetRoot :: a -> m Menuitem
clientGetRoot client :: a
client = IO Menuitem -> m Menuitem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Menuitem -> m Menuitem) -> IO Menuitem -> m Menuitem
forall a b. (a -> b) -> a -> b
$ do
    Ptr Client
client' <- a -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
client
    Ptr Menuitem
result <- Ptr Client -> IO (Ptr Menuitem)
dbusmenu_client_get_root Ptr Client
client'
    Text -> Ptr Menuitem -> ClientLayoutUpdatedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> ClientLayoutUpdatedCallback
checkUnexpectedReturnNULL "clientGetRoot" Ptr Menuitem
result
    Menuitem
result' <- ((ManagedPtr Menuitem -> Menuitem) -> Ptr Menuitem -> IO Menuitem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menuitem -> Menuitem
Dbusmenu.Menuitem.Menuitem) Ptr Menuitem
result
    a -> ClientLayoutUpdatedCallback
forall a. ManagedPtrNewtype a => a -> ClientLayoutUpdatedCallback
touchManagedPtr a
client
    Menuitem -> IO Menuitem
forall (m :: * -> *) a. Monad m => a -> m a
return Menuitem
result'

#if ENABLE_OVERLOADING
data ClientGetRootMethodInfo
instance (signature ~ (m Dbusmenu.Menuitem.Menuitem), MonadIO m, IsClient a) => O.MethodInfo ClientGetRootMethodInfo a signature where
    overloadedMethod _ = clientGetRoot

#endif

-- method Client::get_status
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "Dbusmenu", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#DbusmenuClient to check the status on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Dbusmenu", name = "Status"}))
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_get_status" dbusmenu_client_get_status :: 
    Ptr Client ->                           -- client : TInterface (Name {namespace = "Dbusmenu", name = "Client"})
    IO CUInt

{- |
Gets the recommended current status that the server
	is exporting for the menus.  In situtations where the
	value is @/DBUSMENU_STATUS_NOTICE/@ it is recommended that
	the client show the menus to the user an a more noticible
	way.

	Return value: Status being exported.
-}
clientGetStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
    a
    {- ^ /@client@/: 'GI.Dbusmenu.Objects.Client.Client' to check the status on -}
    -> m Dbusmenu.Enums.Status
clientGetStatus :: a -> m Status
clientGetStatus client :: a
client = IO Status -> m Status
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Status -> m Status) -> IO Status -> m Status
forall a b. (a -> b) -> a -> b
$ do
    Ptr Client
client' <- a -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
client
    CUInt
result <- Ptr Client -> IO CUInt
dbusmenu_client_get_status Ptr Client
client'
    let result' :: Status
result' = (Int -> Status
forall a. Enum a => Int -> a
toEnum (Int -> Status) -> (CUInt -> Int) -> CUInt -> Status
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> ClientLayoutUpdatedCallback
forall a. ManagedPtrNewtype a => a -> ClientLayoutUpdatedCallback
touchManagedPtr a
client
    Status -> IO Status
forall (m :: * -> *) a. Monad m => a -> m a
return Status
result'

#if ENABLE_OVERLOADING
data ClientGetStatusMethodInfo
instance (signature ~ (m Dbusmenu.Enums.Status), MonadIO m, IsClient a) => O.MethodInfo ClientGetStatusMethodInfo a signature where
    overloadedMethod _ = clientGetStatus

#endif

-- method Client::get_text_direction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "Dbusmenu", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#DbusmenuClient to check the text direction on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Dbusmenu", name = "TextDirection"}))
-- throws : False
-- Skip return : False

foreign import ccall "dbusmenu_client_get_text_direction" dbusmenu_client_get_text_direction :: 
    Ptr Client ->                           -- client : TInterface (Name {namespace = "Dbusmenu", name = "Client"})
    IO CUInt

{- |
Gets the text direction that the server is exporting.  If
	the server is not exporting a direction then the value
	@/DBUSMENU_TEXT_DIRECTION_NONE/@ will be returned.

	Return value: Text direction being exported.
-}
clientGetTextDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
    a
    {- ^ /@client@/: 'GI.Dbusmenu.Objects.Client.Client' to check the text direction on -}
    -> m Dbusmenu.Enums.TextDirection
clientGetTextDirection :: a -> m TextDirection
clientGetTextDirection client :: a
client = IO TextDirection -> m TextDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextDirection -> m TextDirection)
-> IO TextDirection -> m TextDirection
forall a b. (a -> b) -> a -> b
$ do
    Ptr Client
client' <- a -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
client
    CUInt
result <- Ptr Client -> IO CUInt
dbusmenu_client_get_text_direction Ptr Client
client'
    let result' :: TextDirection
result' = (Int -> TextDirection
forall a. Enum a => Int -> a
toEnum (Int -> TextDirection) -> (CUInt -> Int) -> CUInt -> TextDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> ClientLayoutUpdatedCallback
forall a. ManagedPtrNewtype a => a -> ClientLayoutUpdatedCallback
touchManagedPtr a
client
    TextDirection -> IO TextDirection
forall (m :: * -> *) a. Monad m => a -> m a
return TextDirection
result'

#if ENABLE_OVERLOADING
data ClientGetTextDirectionMethodInfo
instance (signature ~ (m Dbusmenu.Enums.TextDirection), MonadIO m, IsClient a) => O.MethodInfo ClientGetTextDirectionMethodInfo a signature where
    overloadedMethod _ = clientGetTextDirection

#endif