{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.MenuLinkIter
(
MenuLinkIter(..) ,
IsMenuLinkIter ,
toMenuLinkIter ,
#if defined(ENABLE_OVERLOADING)
ResolveMenuLinkIterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MenuLinkIterGetNameMethodInfo ,
#endif
menuLinkIterGetName ,
#if defined(ENABLE_OVERLOADING)
MenuLinkIterGetNextMethodInfo ,
#endif
menuLinkIterGetNext ,
#if defined(ENABLE_OVERLOADING)
MenuLinkIterGetValueMethodInfo ,
#endif
menuLinkIterGetValue ,
#if defined(ENABLE_OVERLOADING)
MenuLinkIterNextMethodInfo ,
#endif
menuLinkIterNext ,
) 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.GHashTable as B.GHT
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.Coerce as Coerce
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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
newtype = (SP.ManagedPtr MenuLinkIter)
deriving (MenuLinkIter -> MenuLinkIter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MenuLinkIter -> MenuLinkIter -> Bool
$c/= :: MenuLinkIter -> MenuLinkIter -> Bool
== :: MenuLinkIter -> MenuLinkIter -> Bool
$c== :: MenuLinkIter -> MenuLinkIter -> Bool
Eq)
instance SP.ManagedPtrNewtype MenuLinkIter where
toManagedPtr :: MenuLinkIter -> ManagedPtr MenuLinkIter
toManagedPtr (MenuLinkIter ManagedPtr MenuLinkIter
p) = ManagedPtr MenuLinkIter
p
foreign import ccall "g_menu_link_iter_get_type"
:: IO B.Types.GType
instance B.Types.TypedObject MenuLinkIter where
glibType :: IO GType
glibType = IO GType
c_g_menu_link_iter_get_type
instance B.Types.GObject MenuLinkIter
class (SP.GObject o, O.IsDescendantOf MenuLinkIter o) => o
instance (SP.GObject o, O.IsDescendantOf MenuLinkIter o) => IsMenuLinkIter o
instance O.HasParentTypes MenuLinkIter
type instance O.ParentTypes MenuLinkIter = '[GObject.Object.Object]
toMenuLinkIter :: (MIO.MonadIO m, IsMenuLinkIter o) => o -> m MenuLinkIter
= forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr MenuLinkIter -> MenuLinkIter
MenuLinkIter
instance B.GValue.IsGValue (Maybe MenuLinkIter) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_menu_link_iter_get_type
gvalueSet_ :: Ptr GValue -> Maybe MenuLinkIter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MenuLinkIter
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr MenuLinkIter)
gvalueSet_ Ptr GValue
gv (P.Just MenuLinkIter
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MenuLinkIter
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MenuLinkIter)
gvalueGet_ Ptr GValue
gv = do
Ptr MenuLinkIter
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr MenuLinkIter)
if Ptr MenuLinkIter
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr MenuLinkIter -> MenuLinkIter
MenuLinkIter Ptr MenuLinkIter
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveMenuLinkIterMethod (t :: Symbol) (o :: *) :: * where
ResolveMenuLinkIterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveMenuLinkIterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveMenuLinkIterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveMenuLinkIterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveMenuLinkIterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveMenuLinkIterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveMenuLinkIterMethod "next" o = MenuLinkIterNextMethodInfo
ResolveMenuLinkIterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveMenuLinkIterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveMenuLinkIterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveMenuLinkIterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveMenuLinkIterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveMenuLinkIterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveMenuLinkIterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveMenuLinkIterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveMenuLinkIterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveMenuLinkIterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveMenuLinkIterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveMenuLinkIterMethod "getName" o = MenuLinkIterGetNameMethodInfo
ResolveMenuLinkIterMethod "getNext" o = MenuLinkIterGetNextMethodInfo
ResolveMenuLinkIterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveMenuLinkIterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveMenuLinkIterMethod "getValue" o = MenuLinkIterGetValueMethodInfo
ResolveMenuLinkIterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveMenuLinkIterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveMenuLinkIterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveMenuLinkIterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMenuLinkIterMethod t MenuLinkIter, O.OverloadedMethod info MenuLinkIter p) => OL.IsLabel t (MenuLinkIter -> 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 ~ ResolveMenuLinkIterMethod t MenuLinkIter, O.OverloadedMethod info MenuLinkIter p, R.HasField t MenuLinkIter p) => R.HasField t MenuLinkIter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMenuLinkIterMethod t MenuLinkIter, O.OverloadedMethodInfo info MenuLinkIter) => OL.IsLabel t (O.MethodProxy info MenuLinkIter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MenuLinkIter
type instance O.AttributeList MenuLinkIter = MenuLinkIterAttributeList
type MenuLinkIterAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MenuLinkIter = MenuLinkIterSignalList
type MenuLinkIterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_menu_link_iter_get_name" ::
Ptr MenuLinkIter ->
IO CString
menuLinkIterGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuLinkIter a) =>
a
-> m T.Text
a
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MenuLinkIter
iter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
CString
result <- Ptr MenuLinkIter -> IO CString
g_menu_link_iter_get_name Ptr MenuLinkIter
iter'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"menuLinkIterGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
iter
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data MenuLinkIterGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMenuLinkIter a) => O.OverloadedMethod MenuLinkIterGetNameMethodInfo a signature where
overloadedMethod = menuLinkIterGetName
instance O.OverloadedMethodInfo MenuLinkIterGetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuLinkIter.menuLinkIterGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-MenuLinkIter.html#v:menuLinkIterGetName"
})
#endif
foreign import ccall "g_menu_link_iter_get_next" ::
Ptr MenuLinkIter ->
Ptr CString ->
Ptr (Ptr Gio.MenuModel.MenuModel) ->
IO CInt
menuLinkIterGetNext ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuLinkIter a) =>
a
-> m ((Bool, T.Text, Gio.MenuModel.MenuModel))
a
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MenuLinkIter
iter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
Ptr CString
outLink <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr MenuModel)
value <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.MenuModel.MenuModel))
CInt
result <- Ptr MenuLinkIter -> Ptr CString -> Ptr (Ptr MenuModel) -> IO CInt
g_menu_link_iter_get_next Ptr MenuLinkIter
iter' Ptr CString
outLink Ptr (Ptr MenuModel)
value
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
outLink' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outLink
Text
outLink'' <- HasCallStack => CString -> IO Text
cstringToText CString
outLink'
Ptr MenuModel
value' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr MenuModel)
value
MenuModel
value'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
value'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
iter
forall a. Ptr a -> IO ()
freeMem Ptr CString
outLink
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MenuModel)
value
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
outLink'', MenuModel
value'')
#if defined(ENABLE_OVERLOADING)
data MenuLinkIterGetNextMethodInfo
instance (signature ~ (m ((Bool, T.Text, Gio.MenuModel.MenuModel))), MonadIO m, IsMenuLinkIter a) => O.OverloadedMethod MenuLinkIterGetNextMethodInfo a signature where
overloadedMethod = menuLinkIterGetNext
instance O.OverloadedMethodInfo MenuLinkIterGetNextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuLinkIter.menuLinkIterGetNext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-MenuLinkIter.html#v:menuLinkIterGetNext"
})
#endif
foreign import ccall "g_menu_link_iter_get_value" ::
Ptr MenuLinkIter ->
IO (Ptr Gio.MenuModel.MenuModel)
menuLinkIterGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuLinkIter a) =>
a
-> m Gio.MenuModel.MenuModel
a
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MenuLinkIter
iter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
Ptr MenuModel
result <- Ptr MenuLinkIter -> IO (Ptr MenuModel)
g_menu_link_iter_get_value Ptr MenuLinkIter
iter'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"menuLinkIterGetValue" Ptr MenuModel
result
MenuModel
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
iter
forall (m :: * -> *) a. Monad m => a -> m a
return MenuModel
result'
#if defined(ENABLE_OVERLOADING)
data MenuLinkIterGetValueMethodInfo
instance (signature ~ (m Gio.MenuModel.MenuModel), MonadIO m, IsMenuLinkIter a) => O.OverloadedMethod MenuLinkIterGetValueMethodInfo a signature where
overloadedMethod = menuLinkIterGetValue
instance O.OverloadedMethodInfo MenuLinkIterGetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuLinkIter.menuLinkIterGetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-MenuLinkIter.html#v:menuLinkIterGetValue"
})
#endif
foreign import ccall "g_menu_link_iter_next" ::
Ptr MenuLinkIter ->
IO CInt
menuLinkIterNext ::
(B.CallStack.HasCallStack, MonadIO m, IsMenuLinkIter a) =>
a
-> m Bool
a
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MenuLinkIter
iter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
CInt
result <- Ptr MenuLinkIter -> IO CInt
g_menu_link_iter_next Ptr MenuLinkIter
iter'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
iter
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MenuLinkIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMenuLinkIter a) => O.OverloadedMethod MenuLinkIterNextMethodInfo a signature where
overloadedMethod = menuLinkIterNext
instance O.OverloadedMethodInfo MenuLinkIterNextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.MenuLinkIter.menuLinkIterNext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-MenuLinkIter.html#v:menuLinkIterNext"
})
#endif