{-# 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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuAttributeIter as Gio.MenuAttributeIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
#endif
newtype = (SP.ManagedPtr MenuLinkIter)
deriving (MenuLinkIter -> MenuLinkIter -> Bool
(MenuLinkIter -> MenuLinkIter -> Bool)
-> (MenuLinkIter -> MenuLinkIter -> Bool) -> Eq MenuLinkIter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MenuLinkIter -> MenuLinkIter -> Bool
== :: MenuLinkIter -> MenuLinkIter -> Bool
$c/= :: MenuLinkIter -> MenuLinkIter -> Bool
/= :: 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
= IO MenuLinkIter -> m MenuLinkIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO MenuLinkIter -> m MenuLinkIter)
-> (o -> IO MenuLinkIter) -> o -> m MenuLinkIter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr MenuLinkIter -> MenuLinkIter) -> o -> IO MenuLinkIter
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 = Ptr GValue -> Ptr MenuLinkIter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr MenuLinkIter
forall a. Ptr a
FP.nullPtr :: FP.Ptr MenuLinkIter)
gvalueSet_ Ptr GValue
gv (P.Just MenuLinkIter
obj) = MenuLinkIter -> (Ptr MenuLinkIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MenuLinkIter
obj (Ptr GValue -> Ptr MenuLinkIter -> IO ()
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 <- Ptr GValue -> IO (Ptr MenuLinkIter)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr MenuLinkIter)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject MenuLinkIter ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveMenuLinkIterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MenuLinkIter = MenuLinkIterSignalList
type MenuLinkIterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#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 = IO Text -> m Text
forall a. IO a -> m a
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
iter' <- a -> IO (Ptr MenuLinkIter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
result <- g_menu_link_iter_get_name iter'
checkUnexpectedReturnNULL "menuLinkIterGetName" result
result' <- cstringToText result
touchManagedPtr iter
return 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.35/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 = IO (Bool, Text, MenuModel) -> m (Bool, Text, MenuModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, MenuModel) -> m (Bool, Text, MenuModel))
-> IO (Bool, Text, MenuModel) -> m (Bool, Text, MenuModel)
forall a b. (a -> b) -> a -> b
$ do
iter' <- a -> IO (Ptr MenuLinkIter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
outLink <- callocMem :: IO (Ptr CString)
value <- callocMem :: IO (Ptr (Ptr Gio.MenuModel.MenuModel))
result <- g_menu_link_iter_get_next iter' outLink value
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
outLink' <- peek outLink
outLink'' <- cstringToText outLink'
value' <- peek value
value'' <- (wrapObject Gio.MenuModel.MenuModel) value'
touchManagedPtr iter
freeMem outLink
freeMem value
return (result', outLink'', 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.35/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 = IO MenuModel -> m MenuModel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MenuModel -> m MenuModel) -> IO MenuModel -> m MenuModel
forall a b. (a -> b) -> a -> b
$ do
iter' <- a -> IO (Ptr MenuLinkIter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
result <- g_menu_link_iter_get_value iter'
checkUnexpectedReturnNULL "menuLinkIterGetValue" result
result' <- (wrapObject Gio.MenuModel.MenuModel) result
touchManagedPtr iter
return 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.35/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 = IO Bool -> m Bool
forall a. IO a -> m a
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
iter' <- a -> IO (Ptr MenuLinkIter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
iter
result <- g_menu_link_iter_next iter'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr iter
return 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.35/docs/GI-Gio-Objects-MenuLinkIter.html#v:menuLinkIterNext"
})
#endif