#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Dbusmenu.Objects.Client
(
Client(..) ,
IsClient ,
toClient ,
noClient ,
#if ENABLE_OVERLOADING
ClientAddTypeHandlerMethodInfo ,
#endif
clientAddTypeHandler ,
#if ENABLE_OVERLOADING
ClientAddTypeHandlerFullMethodInfo ,
#endif
clientAddTypeHandlerFull ,
#if ENABLE_OVERLOADING
ClientGetIconPathsMethodInfo ,
#endif
clientGetIconPaths ,
#if ENABLE_OVERLOADING
ClientGetRootMethodInfo ,
#endif
clientGetRoot ,
#if ENABLE_OVERLOADING
ClientGetStatusMethodInfo ,
#endif
clientGetStatus ,
#if ENABLE_OVERLOADING
ClientGetTextDirectionMethodInfo ,
#endif
clientGetTextDirection ,
clientNew ,
#if ENABLE_OVERLOADING
ClientDbusNamePropertyInfo ,
#endif
#if ENABLE_OVERLOADING
clientDbusName ,
#endif
constructClientDbusName ,
getClientDbusName ,
#if ENABLE_OVERLOADING
ClientDbusObjectPropertyInfo ,
#endif
#if ENABLE_OVERLOADING
clientDbusObject ,
#endif
constructClientDbusObject ,
getClientDbusObject ,
#if ENABLE_OVERLOADING
ClientGroupEventsPropertyInfo ,
#endif
#if ENABLE_OVERLOADING
clientGroupEvents ,
#endif
constructClientGroupEvents ,
getClientGroupEvents ,
setClientGroupEvents ,
C_ClientEventResultCallback ,
ClientEventResultCallback ,
#if ENABLE_OVERLOADING
ClientEventResultSignalInfo ,
#endif
afterClientEventResult ,
genClosure_ClientEventResult ,
mk_ClientEventResultCallback ,
noClientEventResultCallback ,
onClientEventResult ,
wrap_ClientEventResultCallback ,
C_ClientIconThemeDirsChangedCallback ,
ClientIconThemeDirsChangedCallback ,
#if ENABLE_OVERLOADING
ClientIconThemeDirsChangedSignalInfo ,
#endif
afterClientIconThemeDirsChanged ,
genClosure_ClientIconThemeDirsChanged ,
mk_ClientIconThemeDirsChangedCallback ,
noClientIconThemeDirsChangedCallback ,
onClientIconThemeDirsChanged ,
wrap_ClientIconThemeDirsChangedCallback ,
C_ClientItemActivateCallback ,
ClientItemActivateCallback ,
#if ENABLE_OVERLOADING
ClientItemActivateSignalInfo ,
#endif
afterClientItemActivate ,
genClosure_ClientItemActivate ,
mk_ClientItemActivateCallback ,
noClientItemActivateCallback ,
onClientItemActivate ,
wrap_ClientItemActivateCallback ,
C_ClientLayoutUpdatedCallback ,
ClientLayoutUpdatedCallback ,
#if ENABLE_OVERLOADING
ClientLayoutUpdatedSignalInfo ,
#endif
afterClientLayoutUpdated ,
genClosure_ClientLayoutUpdated ,
mk_ClientLayoutUpdatedCallback ,
noClientLayoutUpdatedCallback ,
onClientLayoutUpdated ,
wrap_ClientLayoutUpdatedCallback ,
C_ClientNewMenuitemCallback ,
ClientNewMenuitemCallback ,
#if ENABLE_OVERLOADING
ClientNewMenuitemSignalInfo ,
#endif
afterClientNewMenuitem ,
genClosure_ClientNewMenuitem ,
mk_ClientNewMenuitemCallback ,
noClientNewMenuitemCallback ,
onClientNewMenuitem ,
wrap_ClientNewMenuitemCallback ,
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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.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
newtype Client = Client (ManagedPtr Client)
foreign import ccall "dbusmenu_client_get_type"
c_dbusmenu_client_get_type :: IO GType
instance GObject Client where
gobjectType = c_dbusmenu_client_get_type
class (GObject o, O.IsDescendantOf Client o) => IsClient o
instance (GObject o, O.IsDescendantOf Client o) => IsClient o
instance O.HasParentTypes Client
type instance O.ParentTypes Client = '[GObject.Object.Object]
toClient :: (MonadIO m, IsClient o) => o -> m Client
toClient = liftIO . unsafeCastTo Client
noClient :: Maybe Client
noClient = 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) => OL.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
type ClientEventResultCallback =
GObject.Object.Object
-> T.Text
-> GVariant
-> Word32
-> Ptr ()
-> IO ()
noClientEventResultCallback :: Maybe ClientEventResultCallback
noClientEventResultCallback = Nothing
type C_ClientEventResultCallback =
Ptr () ->
Ptr GObject.Object.Object ->
CString ->
Ptr GVariant ->
Word32 ->
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ClientEventResultCallback :: C_ClientEventResultCallback -> IO (FunPtr C_ClientEventResultCallback)
genClosure_ClientEventResult :: MonadIO m => ClientEventResultCallback -> m (GClosure C_ClientEventResultCallback)
genClosure_ClientEventResult cb = liftIO $ do
let cb' = wrap_ClientEventResultCallback cb
mk_ClientEventResultCallback cb' >>= B.GClosure.newGClosure
wrap_ClientEventResultCallback ::
ClientEventResultCallback ->
C_ClientEventResultCallback
wrap_ClientEventResultCallback _cb _ object p0 p1 p2 p3 _ = do
object' <- (newObject GObject.Object.Object) object
p0' <- cstringToText p0
p1' <- B.GVariant.newGVariantFromPtr p1
_cb object' p0' p1' p2 p3
onClientEventResult :: (IsClient a, MonadIO m) => a -> ClientEventResultCallback -> m SignalHandlerId
onClientEventResult obj cb = liftIO $ do
let cb' = wrap_ClientEventResultCallback cb
cb'' <- mk_ClientEventResultCallback cb'
connectSignalFunPtr obj "event-result" cb'' SignalConnectBefore
afterClientEventResult :: (IsClient a, MonadIO m) => a -> ClientEventResultCallback -> m SignalHandlerId
afterClientEventResult obj cb = liftIO $ do
let cb' = wrap_ClientEventResultCallback cb
cb'' <- mk_ClientEventResultCallback cb'
connectSignalFunPtr obj "event-result" cb'' SignalConnectAfter
type ClientIconThemeDirsChangedCallback =
Ptr ()
-> IO ()
noClientIconThemeDirsChangedCallback :: Maybe ClientIconThemeDirsChangedCallback
noClientIconThemeDirsChangedCallback = Nothing
type C_ClientIconThemeDirsChangedCallback =
Ptr () ->
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ClientIconThemeDirsChangedCallback :: C_ClientIconThemeDirsChangedCallback -> IO (FunPtr C_ClientIconThemeDirsChangedCallback)
genClosure_ClientIconThemeDirsChanged :: MonadIO m => ClientIconThemeDirsChangedCallback -> m (GClosure C_ClientIconThemeDirsChangedCallback)
genClosure_ClientIconThemeDirsChanged cb = liftIO $ do
let cb' = wrap_ClientIconThemeDirsChangedCallback cb
mk_ClientIconThemeDirsChangedCallback cb' >>= B.GClosure.newGClosure
wrap_ClientIconThemeDirsChangedCallback ::
ClientIconThemeDirsChangedCallback ->
C_ClientIconThemeDirsChangedCallback
wrap_ClientIconThemeDirsChangedCallback _cb _ arg1 _ = do
_cb arg1
onClientIconThemeDirsChanged :: (IsClient a, MonadIO m) => a -> ClientIconThemeDirsChangedCallback -> m SignalHandlerId
onClientIconThemeDirsChanged obj cb = liftIO $ do
let cb' = wrap_ClientIconThemeDirsChangedCallback cb
cb'' <- mk_ClientIconThemeDirsChangedCallback cb'
connectSignalFunPtr obj "icon-theme-dirs-changed" cb'' SignalConnectBefore
afterClientIconThemeDirsChanged :: (IsClient a, MonadIO m) => a -> ClientIconThemeDirsChangedCallback -> m SignalHandlerId
afterClientIconThemeDirsChanged obj cb = liftIO $ do
let cb' = wrap_ClientIconThemeDirsChangedCallback cb
cb'' <- mk_ClientIconThemeDirsChangedCallback cb'
connectSignalFunPtr obj "icon-theme-dirs-changed" cb'' SignalConnectAfter
type ClientItemActivateCallback =
GObject.Object.Object
-> Word32
-> IO ()
noClientItemActivateCallback :: Maybe ClientItemActivateCallback
noClientItemActivateCallback = Nothing
type C_ClientItemActivateCallback =
Ptr () ->
Ptr GObject.Object.Object ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ClientItemActivateCallback :: C_ClientItemActivateCallback -> IO (FunPtr C_ClientItemActivateCallback)
genClosure_ClientItemActivate :: MonadIO m => ClientItemActivateCallback -> m (GClosure C_ClientItemActivateCallback)
genClosure_ClientItemActivate cb = liftIO $ do
let cb' = wrap_ClientItemActivateCallback cb
mk_ClientItemActivateCallback cb' >>= B.GClosure.newGClosure
wrap_ClientItemActivateCallback ::
ClientItemActivateCallback ->
C_ClientItemActivateCallback
wrap_ClientItemActivateCallback _cb _ arg1 arg2 _ = do
arg1' <- (newObject GObject.Object.Object) arg1
_cb arg1' arg2
onClientItemActivate :: (IsClient a, MonadIO m) => a -> ClientItemActivateCallback -> m SignalHandlerId
onClientItemActivate obj cb = liftIO $ do
let cb' = wrap_ClientItemActivateCallback cb
cb'' <- mk_ClientItemActivateCallback cb'
connectSignalFunPtr obj "item-activate" cb'' SignalConnectBefore
afterClientItemActivate :: (IsClient a, MonadIO m) => a -> ClientItemActivateCallback -> m SignalHandlerId
afterClientItemActivate obj cb = liftIO $ do
let cb' = wrap_ClientItemActivateCallback cb
cb'' <- mk_ClientItemActivateCallback cb'
connectSignalFunPtr obj "item-activate" cb'' SignalConnectAfter
type ClientLayoutUpdatedCallback =
IO ()
noClientLayoutUpdatedCallback :: Maybe ClientLayoutUpdatedCallback
noClientLayoutUpdatedCallback = Nothing
type C_ClientLayoutUpdatedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ClientLayoutUpdatedCallback :: C_ClientLayoutUpdatedCallback -> IO (FunPtr C_ClientLayoutUpdatedCallback)
genClosure_ClientLayoutUpdated :: MonadIO m => ClientLayoutUpdatedCallback -> m (GClosure C_ClientLayoutUpdatedCallback)
genClosure_ClientLayoutUpdated cb = liftIO $ do
let cb' = wrap_ClientLayoutUpdatedCallback cb
mk_ClientLayoutUpdatedCallback cb' >>= B.GClosure.newGClosure
wrap_ClientLayoutUpdatedCallback ::
ClientLayoutUpdatedCallback ->
C_ClientLayoutUpdatedCallback
wrap_ClientLayoutUpdatedCallback _cb _ _ = do
_cb
onClientLayoutUpdated :: (IsClient a, MonadIO m) => a -> ClientLayoutUpdatedCallback -> m SignalHandlerId
onClientLayoutUpdated obj cb = liftIO $ do
let cb' = wrap_ClientLayoutUpdatedCallback cb
cb'' <- mk_ClientLayoutUpdatedCallback cb'
connectSignalFunPtr obj "layout-updated" cb'' SignalConnectBefore
afterClientLayoutUpdated :: (IsClient a, MonadIO m) => a -> ClientLayoutUpdatedCallback -> m SignalHandlerId
afterClientLayoutUpdated obj cb = liftIO $ do
let cb' = wrap_ClientLayoutUpdatedCallback cb
cb'' <- mk_ClientLayoutUpdatedCallback cb'
connectSignalFunPtr obj "layout-updated" cb'' SignalConnectAfter
type ClientNewMenuitemCallback =
GObject.Object.Object
-> IO ()
noClientNewMenuitemCallback :: Maybe ClientNewMenuitemCallback
noClientNewMenuitemCallback = Nothing
type C_ClientNewMenuitemCallback =
Ptr () ->
Ptr GObject.Object.Object ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ClientNewMenuitemCallback :: C_ClientNewMenuitemCallback -> IO (FunPtr C_ClientNewMenuitemCallback)
genClosure_ClientNewMenuitem :: MonadIO m => ClientNewMenuitemCallback -> m (GClosure C_ClientNewMenuitemCallback)
genClosure_ClientNewMenuitem cb = liftIO $ do
let cb' = wrap_ClientNewMenuitemCallback cb
mk_ClientNewMenuitemCallback cb' >>= B.GClosure.newGClosure
wrap_ClientNewMenuitemCallback ::
ClientNewMenuitemCallback ->
C_ClientNewMenuitemCallback
wrap_ClientNewMenuitemCallback _cb _ arg1 _ = do
arg1' <- (newObject GObject.Object.Object) arg1
_cb arg1'
onClientNewMenuitem :: (IsClient a, MonadIO m) => a -> ClientNewMenuitemCallback -> m SignalHandlerId
onClientNewMenuitem obj cb = liftIO $ do
let cb' = wrap_ClientNewMenuitemCallback cb
cb'' <- mk_ClientNewMenuitemCallback cb'
connectSignalFunPtr obj "new-menuitem" cb'' SignalConnectBefore
afterClientNewMenuitem :: (IsClient a, MonadIO m) => a -> ClientNewMenuitemCallback -> m SignalHandlerId
afterClientNewMenuitem obj cb = liftIO $ do
let cb' = wrap_ClientNewMenuitemCallback cb
cb'' <- mk_ClientNewMenuitemCallback cb'
connectSignalFunPtr obj "new-menuitem" cb'' SignalConnectAfter
type ClientRootChangedCallback =
GObject.Object.Object
-> IO ()
noClientRootChangedCallback :: Maybe ClientRootChangedCallback
noClientRootChangedCallback = Nothing
type C_ClientRootChangedCallback =
Ptr () ->
Ptr GObject.Object.Object ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ClientRootChangedCallback :: C_ClientRootChangedCallback -> IO (FunPtr C_ClientRootChangedCallback)
genClosure_ClientRootChanged :: MonadIO m => ClientRootChangedCallback -> m (GClosure C_ClientRootChangedCallback)
genClosure_ClientRootChanged cb = liftIO $ do
let cb' = wrap_ClientRootChangedCallback cb
mk_ClientRootChangedCallback cb' >>= B.GClosure.newGClosure
wrap_ClientRootChangedCallback ::
ClientRootChangedCallback ->
C_ClientRootChangedCallback
wrap_ClientRootChangedCallback _cb _ arg1 _ = do
arg1' <- (newObject GObject.Object.Object) arg1
_cb arg1'
onClientRootChanged :: (IsClient a, MonadIO m) => a -> ClientRootChangedCallback -> m SignalHandlerId
onClientRootChanged obj cb = liftIO $ do
let cb' = wrap_ClientRootChangedCallback cb
cb'' <- mk_ClientRootChangedCallback cb'
connectSignalFunPtr obj "root-changed" cb'' SignalConnectBefore
afterClientRootChanged :: (IsClient a, MonadIO m) => a -> ClientRootChangedCallback -> m SignalHandlerId
afterClientRootChanged obj cb = liftIO $ do
let cb' = wrap_ClientRootChangedCallback cb
cb'' <- mk_ClientRootChangedCallback cb'
connectSignalFunPtr obj "root-changed" cb'' SignalConnectAfter
getClientDbusName :: (MonadIO m, IsClient o) => o -> m (Maybe T.Text)
getClientDbusName obj = liftIO $ B.Properties.getObjectPropertyString obj "dbus-name"
constructClientDbusName :: (IsClient o) => T.Text -> IO (GValueConstruct o)
constructClientDbusName val = B.Properties.constructObjectPropertyString "dbus-name" (Just 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
getClientDbusObject :: (MonadIO m, IsClient o) => o -> m (Maybe T.Text)
getClientDbusObject obj = liftIO $ B.Properties.getObjectPropertyString obj "dbus-object"
constructClientDbusObject :: (IsClient o) => T.Text -> IO (GValueConstruct o)
constructClientDbusObject val = B.Properties.constructObjectPropertyString "dbus-object" (Just 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
getClientGroupEvents :: (MonadIO m, IsClient o) => o -> m Bool
getClientGroupEvents obj = liftIO $ B.Properties.getObjectPropertyBool obj "group-events"
setClientGroupEvents :: (MonadIO m, IsClient o) => o -> Bool -> m ()
setClientGroupEvents obj val = liftIO $ B.Properties.setObjectPropertyBool obj "group-events" val
constructClientGroupEvents :: (IsClient o) => Bool -> IO (GValueConstruct o)
constructClientGroupEvents val = B.Properties.constructObjectPropertyBool "group-events" 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
foreign import ccall "dbusmenu_client_new" dbusmenu_client_new ::
CString ->
CString ->
IO (Ptr Client)
clientNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m Client
clientNew name object = liftIO $ do
name' <- textToCString name
object' <- textToCString object
result <- dbusmenu_client_new name' object'
checkUnexpectedReturnNULL "clientNew" result
result' <- (wrapObject Client) result
freeMem name'
freeMem object'
return result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "dbusmenu_client_add_type_handler" dbusmenu_client_add_type_handler ::
Ptr Client ->
CString ->
FunPtr Dbusmenu.Callbacks.C_ClientTypeHandler ->
IO CInt
clientAddTypeHandler ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> T.Text
-> Dbusmenu.Callbacks.ClientTypeHandler
-> m Bool
clientAddTypeHandler client type_ newfunc = liftIO $ do
client' <- unsafeManagedPtrCastPtr client
type_' <- textToCString type_
newfunc' <- Dbusmenu.Callbacks.mk_ClientTypeHandler (Dbusmenu.Callbacks.wrap_ClientTypeHandler Nothing (Dbusmenu.Callbacks.drop_closures_ClientTypeHandler newfunc))
result <- dbusmenu_client_add_type_handler client' type_' newfunc'
let result' = (/= 0) result
touchManagedPtr client
freeMem type_'
return 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
foreign import ccall "dbusmenu_client_add_type_handler_full" dbusmenu_client_add_type_handler_full ::
Ptr Client ->
CString ->
FunPtr Dbusmenu.Callbacks.C_ClientTypeHandler ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CInt
clientAddTypeHandlerFull ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> T.Text
-> Dbusmenu.Callbacks.ClientTypeHandler
-> m Bool
clientAddTypeHandlerFull client type_ newfunc = liftIO $ do
client' <- unsafeManagedPtrCastPtr client
type_' <- textToCString type_
newfunc' <- Dbusmenu.Callbacks.mk_ClientTypeHandler (Dbusmenu.Callbacks.wrap_ClientTypeHandler Nothing (Dbusmenu.Callbacks.drop_closures_ClientTypeHandler newfunc))
let userData = castFunPtrToPtr newfunc'
let destroyFunc = safeFreeFunPtrPtr
result <- dbusmenu_client_add_type_handler_full client' type_' newfunc' userData destroyFunc
let result' = (/= 0) result
touchManagedPtr client
freeMem type_'
return 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
foreign import ccall "dbusmenu_client_get_icon_paths" dbusmenu_client_get_icon_paths ::
Ptr Client ->
IO (Ptr CString)
clientGetIconPaths ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> m [T.Text]
clientGetIconPaths client = liftIO $ do
client' <- unsafeManagedPtrCastPtr client
result <- dbusmenu_client_get_icon_paths client'
checkUnexpectedReturnNULL "clientGetIconPaths" result
result' <- unpackZeroTerminatedUTF8CArray result
touchManagedPtr client
return result'
#if ENABLE_OVERLOADING
data ClientGetIconPathsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsClient a) => O.MethodInfo ClientGetIconPathsMethodInfo a signature where
overloadedMethod _ = clientGetIconPaths
#endif
foreign import ccall "dbusmenu_client_get_root" dbusmenu_client_get_root ::
Ptr Client ->
IO (Ptr Dbusmenu.Menuitem.Menuitem)
clientGetRoot ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> m Dbusmenu.Menuitem.Menuitem
clientGetRoot client = liftIO $ do
client' <- unsafeManagedPtrCastPtr client
result <- dbusmenu_client_get_root client'
checkUnexpectedReturnNULL "clientGetRoot" result
result' <- (newObject Dbusmenu.Menuitem.Menuitem) result
touchManagedPtr client
return 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
foreign import ccall "dbusmenu_client_get_status" dbusmenu_client_get_status ::
Ptr Client ->
IO CUInt
clientGetStatus ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> m Dbusmenu.Enums.Status
clientGetStatus client = liftIO $ do
client' <- unsafeManagedPtrCastPtr client
result <- dbusmenu_client_get_status client'
let result' = (toEnum . fromIntegral) result
touchManagedPtr client
return 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
foreign import ccall "dbusmenu_client_get_text_direction" dbusmenu_client_get_text_direction ::
Ptr Client ->
IO CUInt
clientGetTextDirection ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> m Dbusmenu.Enums.TextDirection
clientGetTextDirection client = liftIO $ do
client' <- unsafeManagedPtrCastPtr client
result <- dbusmenu_client_get_text_direction client'
let result' = (toEnum . fromIntegral) result
touchManagedPtr client
return 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