{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.DbusmenuGtk3.Objects.Client
(
Client(..) ,
IsClient ,
toClient ,
#if defined(ENABLE_OVERLOADING)
ResolveClientMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ClientGetAccelGroupMethodInfo ,
#endif
clientGetAccelGroup ,
#if defined(ENABLE_OVERLOADING)
ClientMenuitemGetMethodInfo ,
#endif
clientMenuitemGet ,
#if defined(ENABLE_OVERLOADING)
ClientMenuitemGetSubmenuMethodInfo ,
#endif
clientMenuitemGetSubmenu ,
clientNew ,
#if defined(ENABLE_OVERLOADING)
ClientNewitemBaseMethodInfo ,
#endif
clientNewitemBase ,
#if defined(ENABLE_OVERLOADING)
ClientSetAccelGroupMethodInfo ,
#endif
clientSetAccelGroup ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 GHC.Records as R
import qualified GI.Dbusmenu.Objects.Client as Dbusmenu.Client
import qualified GI.Dbusmenu.Objects.Menuitem as Dbusmenu.Menuitem
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup
import qualified GI.Gtk.Objects.Menu as Gtk.Menu
import qualified GI.Gtk.Objects.MenuItem as Gtk.MenuItem
newtype Client = Client (SP.ManagedPtr Client)
deriving (Client -> Client -> Bool
(Client -> Client -> Bool)
-> (Client -> Client -> Bool) -> Eq Client
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Client -> Client -> Bool
$c/= :: Client -> Client -> Bool
== :: Client -> Client -> Bool
$c== :: Client -> Client -> Bool
Eq)
instance SP.ManagedPtrNewtype Client where
toManagedPtr :: Client -> ManagedPtr Client
toManagedPtr (Client ManagedPtr Client
p) = ManagedPtr Client
p
foreign import ccall "dbusmenu_gtkclient_get_type"
:: IO B.Types.GType
instance B.Types.TypedObject Client where
glibType :: IO GType
glibType = IO GType
c_dbusmenu_gtkclient_get_type
instance B.Types.GObject Client
class (SP.GObject o, O.IsDescendantOf Client o) => IsClient o
instance (SP.GObject o, O.IsDescendantOf Client o) => IsClient o
instance O.HasParentTypes Client
type instance O.ParentTypes Client = '[Dbusmenu.Client.Client, GObject.Object.Object]
toClient :: (MIO.MonadIO m, IsClient o) => o -> m Client
toClient :: forall (m :: * -> *) o. (MonadIO m, IsClient o) => o -> m Client
toClient = IO Client -> m Client
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Client -> Client
Client
instance B.GValue.IsGValue (Maybe Client) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dbusmenu_gtkclient_get_type
gvalueSet_ :: Ptr GValue -> Maybe Client -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Client
P.Nothing = Ptr GValue -> Ptr Client -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Client
forall a. Ptr a
FP.nullPtr :: FP.Ptr Client)
gvalueSet_ Ptr GValue
gv (P.Just Client
obj) = Client -> (Ptr Client -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Client
obj (Ptr GValue -> Ptr Client -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Client)
gvalueGet_ Ptr GValue
gv = do
Ptr Client
ptr <- Ptr GValue -> IO (Ptr Client)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Client)
if Ptr Client
ptr Ptr Client -> Ptr Client -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Client
forall a. Ptr a
FP.nullPtr
then Client -> Maybe Client
forall a. a -> Maybe a
P.Just (Client -> Maybe Client) -> IO Client -> IO (Maybe Client)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Client -> Client) -> Ptr Client -> IO Client
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Client -> Client
Client Ptr Client
ptr
else Maybe Client -> IO (Maybe Client)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Client
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveClientMethod (t :: Symbol) (o :: *) :: * where
ResolveClientMethod "addTypeHandler" o = Dbusmenu.Client.ClientAddTypeHandlerMethodInfo
ResolveClientMethod "addTypeHandlerFull" o = Dbusmenu.Client.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 "menuitemGet" o = ClientMenuitemGetMethodInfo
ResolveClientMethod "menuitemGetSubmenu" o = ClientMenuitemGetSubmenuMethodInfo
ResolveClientMethod "newitemBase" o = ClientNewitemBaseMethodInfo
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 "getAccelGroup" o = ClientGetAccelGroupMethodInfo
ResolveClientMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveClientMethod "getIconPaths" o = Dbusmenu.Client.ClientGetIconPathsMethodInfo
ResolveClientMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveClientMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveClientMethod "getRoot" o = Dbusmenu.Client.ClientGetRootMethodInfo
ResolveClientMethod "getStatus" o = Dbusmenu.Client.ClientGetStatusMethodInfo
ResolveClientMethod "getTextDirection" o = Dbusmenu.Client.ClientGetTextDirectionMethodInfo
ResolveClientMethod "setAccelGroup" o = ClientSetAccelGroupMethodInfo
ResolveClientMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveClientMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveClientMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveClientMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveClientMethod t Client, O.OverloadedMethod info Client p) => OL.IsLabel t (Client -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveClientMethod t Client, O.OverloadedMethod info Client p, R.HasField t Client p) => R.HasField t Client p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveClientMethod t Client, O.OverloadedMethodInfo info Client) => OL.IsLabel t (O.MethodProxy info Client) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Client
type instance O.AttributeList Client = ClientAttributeList
type ClientAttributeList = ('[ '("dbusName", Dbusmenu.Client.ClientDbusNamePropertyInfo), '("dbusObject", Dbusmenu.Client.ClientDbusObjectPropertyInfo), '("groupEvents", Dbusmenu.Client.ClientGroupEventsPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Client = ClientSignalList
type ClientSignalList = ('[ '("eventResult", Dbusmenu.Client.ClientEventResultSignalInfo), '("iconThemeDirsChanged", Dbusmenu.Client.ClientIconThemeDirsChangedSignalInfo), '("itemActivate", Dbusmenu.Client.ClientItemActivateSignalInfo), '("layoutUpdated", Dbusmenu.Client.ClientLayoutUpdatedSignalInfo), '("newMenuitem", Dbusmenu.Client.ClientNewMenuitemSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rootChanged", Dbusmenu.Client.ClientRootChangedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "dbusmenu_gtkclient_new" ::
CString ->
CString ->
IO (Ptr Client)
clientNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m Client
clientNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> m Client
clientNew Text
dbusName Text
dbusObject = 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
dbusName' <- Text -> IO CString
textToCString Text
dbusName
CString
dbusObject' <- Text -> IO CString
textToCString Text
dbusObject
Ptr Client
result <- CString -> CString -> IO (Ptr Client)
dbusmenu_gtkclient_new CString
dbusName' CString
dbusObject'
Text -> Ptr Client -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"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 -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
dbusName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
dbusObject'
Client -> IO Client
forall (m :: * -> *) a. Monad m => a -> m a
return Client
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "dbusmenu_gtkclient_get_accel_group" ::
Ptr Client ->
IO (Ptr Gtk.AccelGroup.AccelGroup)
clientGetAccelGroup ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a) =>
a
-> m Gtk.AccelGroup.AccelGroup
clientGetAccelGroup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClient a) =>
a -> m AccelGroup
clientGetAccelGroup a
client = IO AccelGroup -> m AccelGroup
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AccelGroup -> m AccelGroup) -> IO AccelGroup -> m AccelGroup
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 AccelGroup
result <- Ptr Client -> IO (Ptr AccelGroup)
dbusmenu_gtkclient_get_accel_group Ptr Client
client'
Text -> Ptr AccelGroup -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"clientGetAccelGroup" Ptr AccelGroup
result
AccelGroup
result' <- ((ManagedPtr AccelGroup -> AccelGroup)
-> Ptr AccelGroup -> IO AccelGroup
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AccelGroup -> AccelGroup
Gtk.AccelGroup.AccelGroup) Ptr AccelGroup
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
client
AccelGroup -> IO AccelGroup
forall (m :: * -> *) a. Monad m => a -> m a
return AccelGroup
result'
#if defined(ENABLE_OVERLOADING)
data ClientGetAccelGroupMethodInfo
instance (signature ~ (m Gtk.AccelGroup.AccelGroup), MonadIO m, IsClient a) => O.OverloadedMethod ClientGetAccelGroupMethodInfo a signature where
overloadedMethod = clientGetAccelGroup
instance O.OverloadedMethodInfo ClientGetAccelGroupMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.DbusmenuGtk3.Objects.Client.clientGetAccelGroup",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.10/docs/GI-DbusmenuGtk3-Objects-Client.html#v:clientGetAccelGroup"
}
#endif
foreign import ccall "dbusmenu_gtkclient_menuitem_get" ::
Ptr Client ->
Ptr Dbusmenu.Menuitem.Menuitem ->
IO (Ptr Gtk.MenuItem.MenuItem)
clientMenuitemGet ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) =>
a
-> b
-> m Gtk.MenuItem.MenuItem
a
client b
item = 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
item' <- b -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
item
Ptr MenuItem
result <- Ptr Client -> Ptr Menuitem -> IO (Ptr MenuItem)
dbusmenu_gtkclient_menuitem_get Ptr Client
client' Ptr Menuitem
item'
Text -> Ptr MenuItem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"clientMenuitemGet" 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
Gtk.MenuItem.MenuItem) Ptr MenuItem
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
client
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
item
MenuItem -> IO MenuItem
forall (m :: * -> *) a. Monad m => a -> m a
return MenuItem
result'
#if defined(ENABLE_OVERLOADING)
data ClientMenuitemGetMethodInfo
instance (signature ~ (b -> m Gtk.MenuItem.MenuItem), MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) => O.OverloadedMethod ClientMenuitemGetMethodInfo a signature where
overloadedMethod = clientMenuitemGet
instance O.OverloadedMethodInfo ClientMenuitemGetMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.DbusmenuGtk3.Objects.Client.clientMenuitemGet",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.10/docs/GI-DbusmenuGtk3-Objects-Client.html#v:clientMenuitemGet"
}
#endif
foreign import ccall "dbusmenu_gtkclient_menuitem_get_submenu" ::
Ptr Client ->
Ptr Dbusmenu.Menuitem.Menuitem ->
IO (Ptr Gtk.Menu.Menu)
clientMenuitemGetSubmenu ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) =>
a
-> b
-> m Gtk.Menu.Menu
a
client b
item = IO Menu -> m Menu
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Menu -> m Menu) -> IO Menu -> m Menu
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
item' <- b -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
item
Ptr Menu
result <- Ptr Client -> Ptr Menuitem -> IO (Ptr Menu)
dbusmenu_gtkclient_menuitem_get_submenu Ptr Client
client' Ptr Menuitem
item'
Text -> Ptr Menu -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"clientMenuitemGetSubmenu" Ptr Menu
result
Menu
result' <- ((ManagedPtr Menu -> Menu) -> Ptr Menu -> IO Menu
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menu -> Menu
Gtk.Menu.Menu) Ptr Menu
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
client
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
item
Menu -> IO Menu
forall (m :: * -> *) a. Monad m => a -> m a
return Menu
result'
#if defined(ENABLE_OVERLOADING)
data ClientMenuitemGetSubmenuMethodInfo
instance (signature ~ (b -> m Gtk.Menu.Menu), MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) => O.OverloadedMethod ClientMenuitemGetSubmenuMethodInfo a signature where
overloadedMethod = clientMenuitemGetSubmenu
instance O.OverloadedMethodInfo ClientMenuitemGetSubmenuMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.DbusmenuGtk3.Objects.Client.clientMenuitemGetSubmenu",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.10/docs/GI-DbusmenuGtk3-Objects-Client.html#v:clientMenuitemGetSubmenu"
}
#endif
foreign import ccall "dbusmenu_gtkclient_newitem_base" ::
Ptr Client ->
Ptr Dbusmenu.Menuitem.Menuitem ->
Ptr Gtk.MenuItem.MenuItem ->
Ptr Dbusmenu.Menuitem.Menuitem ->
IO ()
clientNewitemBase ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b, Gtk.MenuItem.IsMenuItem c, Dbusmenu.Menuitem.IsMenuitem d) =>
a
-> b
-> c
-> d
-> m ()
clientNewitemBase :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsClient a, IsMenuitem b, IsMenuItem c,
IsMenuitem d) =>
a -> b -> c -> d -> m ()
clientNewitemBase a
client b
item c
gmi d
parent = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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
item' <- b -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
item
Ptr MenuItem
gmi' <- c -> IO (Ptr MenuItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
gmi
Ptr Menuitem
parent' <- d -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
parent
Ptr Client -> Ptr Menuitem -> Ptr MenuItem -> Ptr Menuitem -> IO ()
dbusmenu_gtkclient_newitem_base Ptr Client
client' Ptr Menuitem
item' Ptr MenuItem
gmi' Ptr Menuitem
parent'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
client
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
item
c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
gmi
d -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr d
parent
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ClientNewitemBaseMethodInfo
instance (signature ~ (b -> c -> d -> m ()), MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b, Gtk.MenuItem.IsMenuItem c, Dbusmenu.Menuitem.IsMenuitem d) => O.OverloadedMethod ClientNewitemBaseMethodInfo a signature where
overloadedMethod = clientNewitemBase
instance O.OverloadedMethodInfo ClientNewitemBaseMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.DbusmenuGtk3.Objects.Client.clientNewitemBase",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.10/docs/GI-DbusmenuGtk3-Objects-Client.html#v:clientNewitemBase"
}
#endif
foreign import ccall "dbusmenu_gtkclient_set_accel_group" ::
Ptr Client ->
Ptr Gtk.AccelGroup.AccelGroup ->
IO ()
clientSetAccelGroup ::
(B.CallStack.HasCallStack, MonadIO m, IsClient a, Gtk.AccelGroup.IsAccelGroup b) =>
a
-> b
-> m ()
clientSetAccelGroup :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClient a, IsAccelGroup b) =>
a -> b -> m ()
clientSetAccelGroup a
client b
agroup = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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 AccelGroup
agroup' <- b -> IO (Ptr AccelGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
agroup
Ptr Client -> Ptr AccelGroup -> IO ()
dbusmenu_gtkclient_set_accel_group Ptr Client
client' Ptr AccelGroup
agroup'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
client
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
agroup
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ClientSetAccelGroupMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsClient a, Gtk.AccelGroup.IsAccelGroup b) => O.OverloadedMethod ClientSetAccelGroupMethodInfo a signature where
overloadedMethod = clientSetAccelGroup
instance O.OverloadedMethodInfo ClientSetAccelGroupMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.DbusmenuGtk3.Objects.Client.clientSetAccelGroup",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.10/docs/GI-DbusmenuGtk3-Objects-Client.html#v:clientSetAccelGroup"
}
#endif